1- 项目环境(传统)
1.1 SQL数据表结构
-- 创建数据库
create database spring;
-- 显示数据库
show databases;
-- 使用数据库
use spring;
-- 创建客户表
CREATE TABLE `cst_customer` (
`cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
`cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
`cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
`cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
`cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
`cust_address` varchar(128) DEFAULT NULL COMMENT '客户联系地址',
`cust_phone` varchar(64) DEFAULT NULL COMMENT '客户联系电话',
PRIMARY KEY (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
-- 添加客户数据
INSERT INTO `cst_customer`
VALUES ('1', '美团外卖','网络营销', '互联网', '普通客户','北京市海淀区北四环西路9号','7758258');
INSERT INTO `cst_customer`
VALUES ('2', '360公司','网络安全', '互联网', '普通客户','北京市朝阳区酒仙桥路6号院','0208888887');
INSERT INTO `cst_customer`
VALUES ('3', '百度','网络搜索', '互联网', '普通客户','北京朝阳区','389056');
INSERT INTO `cst_customer`
VALUES ('4', '小米','手机制造', '互联网+', 'VIP','武汉光谷','2267890');
INSERT INTO `cst_customer`
VALUES ('5', '腾讯','网络广告', '互联网', 'VIP','深圳市南山区','123456');
INSERT INTO `cst_customer`
VALUES ('6', '华为','电视广告', '高新科技制造业', 'VIP','深圳龙岗','033567');
-- 查询数据库
select * from cst_customer;
1.2 项目目录
1.3 导入父依赖(pom.xml)
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cn.guardwhy</groupId>
<artifactId>Spring</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<!--模块-->
<modules>
<module>01_spring_jdbc</module>
</modules>
<properties>
<!-- spring版本 -->
<spring.version>5.2.9.RELEASE</spring.version>
<!-- mysql版本 -->
<mysql.version>5.1.30</mysql.version>
</properties>
<dependencies>
<!--spring 版本-->
<dependency>
<groupId>org.springframework </groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<!--测试依赖-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
</dependency>
<!-- mysql数据库依赖 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
</dependencies>
</project>
1.4 倒入子依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>Spring</artifactId>
<groupId>cn.guardwhy</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>01_spring_jdbc</artifactId>
</project>
1.5 测试代码(jdbc案例)
存在问题: 代码的耦合度太高了
package cn.guardwhy.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
public class JdbcDemo01 {
public static void main(String[] args) {
Connection connection = null;
PreparedStatement psmt = null;
ResultSet rs = null;
try {
// 1.加载驱动
Class.forName("com.mysql.jdbc.Driver");
// 2.创建数据库链接对象
connection = DriverManager.getConnection("jdbc:mysql:///spring", "root", "root");
// 3.定义sql语句
String sql = "select * from cst_customer";
// 4.创建Statement语句对象
psmt = connection.prepareStatement(sql);
// 5.执行操作
rs = psmt.executeQuery();
// 6.处理结果集
while (rs.next()){
System.out.println("客户Id:" + rs.getInt("cust_id") +
", 客户名称:" + rs.getString("cust_name"));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 7.释放资源
try {
if(rs != null) rs.close();
if(psmt != null) psmt.close();
if(connection != null) connection.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
2- 工厂模式解耦环境
2.1 三层架构图示
2.2 项目环境
2.2.1 项目结构
2.2.2 配置文件(bean.properties)
CUSTOMERDAO=cn.guardwhy.dao.impl.CustomerDaoImpl
CUSTOMERSERVICE=cn.guardwhy.service.impl.CustomerServiceImpl
2.2.3 BeanFactory代码
package cn.guardwhy.factory;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
* 工厂类实现
*/
public class BeanFactory {
// 1.声明一个私有的工厂类对象引用
private static BeanFactory beanFactory;
// 2.将构造方法私有化
private BeanFactory(){
}
// 3.通过静态代码块初始化
// 定义Properties
private static Properties prop;
static {
// 创建工厂类对象
beanFactory = new BeanFactory();
// 创建prop对象,加载属性配置文件
prop = new Properties();
InputStream inputStream = BeanFactory.class.getClassLoader().
getResourceAsStream("bean.properties");
try {
prop.load(inputStream);
} catch (IOException e) {
e.printStackTrace();
System.out.println("加载属性资源文件,发生异常:" + e.getMessage());
}
}
// 4.提供一个公有的、静态的方法,获取工厂类对象引用
public static BeanFactory getBeanFactory(){
return beanFactory;
}
/**
* 1.通过配置文件,将要创建的目标对象的类型信息,进行配置
* 2.在工厂类中加载配置文件,通过反射技术实现运行时加载,并创建目标对象
*/
public Object getBean(String beanName){
// 目标对象
Object result = null;
// 获取类路径
String className = prop.getProperty(beanName);
// 反射技术创建对象
try {
result = Class.forName(className).newInstance();
} catch (Exception e) {
e.printStackTrace();
System.out.println("运行时创建对象,发生异常:" + className);
}
return result;
}
}
2.2.4 持久层(Dao层)
- dao层接口
package cn.guardwhy.dao;
/**
* 客户dao接口
*/
public interface CustomerDao {
/**
* 保存客户操作
*/
void saveCustomer();
}
- dao实现类
package cn.guardwhy.dao.impl;
import cn.guardwhy.dao.CustomerDao;
/**
* 客户dao实现类
*/
public class CustomerDaoImpl implements CustomerDao {
@Override
public void saveCustomer() {
System.out.println("保存客户操作");
}
}
2.2.5 业务层(Service)
- service接口
package cn.guardwhy.service;
/**
* 客户service接口
*/
public interface CustomerService {
/**
* 保存客户操作
*/
void saveCustomer();
}
- service实现类
package cn.guardwhy.service.impl;
import cn.guardwhy.dao.CustomerDao;
import cn.guardwhy.factory.BeanFactory;
import cn.guardwhy.service.CustomerService;
/**
* 客户service实现类
*/
public class CustomerServiceImpl implements CustomerService {
// 从工厂类获取客户dao对象
private CustomerDao customerDao = (CustomerDao) BeanFactory.getBeanFactory().getBean("CUSTOMERDAO");
/**
* 保存客户操作
*/
@Override
public void saveCustomer() {
customerDao.saveCustomer();
}
}
2.2.6 表现层(Controller)
- controller
package cn.guardwhy.controller;
import cn.guardwhy.factory.BeanFactory;
import cn.guardwhy.service.CustomerService;
public class CustomerController {
public static void main(String[] args) {
// 从工厂类获取客户端service对象
CustomerService customerService = (CustomerService)
BeanFactory.getBeanFactory().getBean("CUSTOMERSERVICE");
// 保存客户操作
customerService.saveCustomer();
}
}
2.3 工厂模式解耦
工厂就是负责创建对象,并且把对象放到容器中。在实际使用的时候,帮助我们从容器获取指定的对象。此时我们获取对象的方式发生了改变。
原来我们获取对象时,都是采用new的方式,是主动获取。现在我们获取对象时,找工厂要,由工厂创建并且提供给我们,是被动接收
#结论:这种获取对象方式的转变(由原来主动获取,到现在被动接收),我们称它为控制反转。控制反转,即IOC(Inversion Of Control)。
传统获取对象的方式
通过工厂模式获取对象的方式