Spring基础
# Spring基础
# 1. spring优势
- 方便解耦,简化开发
- 通过 Spring 提供的 IoC 容器,可以将对象间的依赖关系交由 Spring 进行控制,避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码,可以更专注于上层的应用。
- AOP 编程的支持
- 声明式事务的支持
- 方便程序的测试
- 方便集成各种优秀框架
- 降低 JavaEE API 的使用难度
# 2. spring体系结构
# 1. spring中文文档
# 3. 入门JDBC操作 程序解耦
/**
* @Author: CHGGX
* @Description: <h1> 程序耦合 </h1>
* 耦合: 程序间的依赖关系
* 1. 类之间依赖
* 2. 方法之间的依赖
* 解耦: 降低程序间的依赖
*
* 开发过程应做到:
* 编译期不依赖,运行期才依赖
* 解耦思路:
* 1. 使用反射来创建对象,避免使用new关键字
* 2. 通过读取配置文件来获取要创建的对象全权限定类名
*
*/
public class JdbcDemo01 {
public static void main(String[] args) throws Exception {
// 1. 注册驱动
// DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Class.forName("new com.mysql.jdbc.Driver()");
// 2. 获取连接
Connection conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/spring_jdbc",
"root",
"root"
);
// 3. 获取操作数据库的与处理对象
PreparedStatement pstm = conn.prepareStatement("select * from account");
// 4. 执行SQL,得到结果
ResultSet resultSet = pstm.executeQuery();
// 5. 遍历结果
while (resultSet.next()) {
System.out.println(resultSet.getString("name"));
}
// 6. 关闭流
resultSet.close();
pstm.close();
conn.close();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# 4. 解耦合
# 1. 配置文件
- bean.properties
accountService=com.chggx.service.impl.AccountServiceImpl
accountDao=com.chggx.dao.impl.AccountDaoImpl
1
2
2
# 2. 业务逻辑
# 1. dao层
- AccountDao
public interface AccountDao {
/**
* 模拟保存账户
*/
void saveAccount();
}
1
2
3
4
5
6
7
2
3
4
5
6
7
- AccountDaoImpl
public class AccountDaoImpl implements AccountDao {
/**
* 模拟保存账户
*/
@Override
public void saveAccount() {
System.out.println("save success...");
}
}
1
2
3
4
5
6
7
8
9
10
2
3
4
5
6
7
8
9
10
# 2. service
- AccountService
public interface AccountService {
/**
* 模拟保存账户
*/
void saveAccount();
}
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
AccountServiceImpl
使用factory工厂的方式获取对象
public class AccountServiceImpl implements AccountService {
/**
* 普通方式 (耦合度高)
*/
// private final AccountDao accountDao = new AccountDaoImpl();
/**
* 解耦合
*/
private final AccountDao accountDao = (AccountDao) BeanFactory.getBean("accountDao");
/**
* 模拟保存账户
*/
@Override
public void saveAccount() {
accountDao.saveAccount();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 3. AccountController
- 解耦合 通过工厂的方式创建对象,实现程序间的解耦合
public class AccountController {
/**
* 模拟保存账户
*/
public static void main(String[] args) {
// 普通方式 (耦合度高)
/* AccountService service = new AccountServiceImpl();
service.saveAccount();*/
// 解耦合
AccountService service = (AccountService) BeanFactory.getBean("accountService");
service.saveAccount();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 3. 工厂模式解耦
- 使用单例,每个对象只创建一次
/**
* @Author: CHGGX
* @Date: 2020/04/28 22:14
* @Description: <h1> 一个创建Bean对象的工厂(解耦合) </h1>
* Bean: 在计算机英语中,有可重用组件的含义
* JavaBean: java语言编写的可重用组件
* 1. JavaBean > 实体类
* 2. 它就是创建我们的service和dao对象的
* 解决:
* 1. 需要一个配置文件来配置我们的service和dao
* 配置内容: 1) 唯一标识=权限定类名
* 2. 通过读取配置文件中的内容,反射创建对象
* <p>
* 配置文件形式:
* 1. xml
* 2. properties: 推荐
*/
public class BeanFactory {
/**
* 定义一个Properties对象
*/
private static Properties props;
/**
* 定义一个Map,用于存放我们要创建的对象,我们称之为容器
*/
private static Map<String, Object> beans;
// 使用静态代码块Properties对象赋值
static {
try {
// 1. 实例化对象
props = new Properties();
// 获取"bean.properties"文件的流对象
// 获取Class对象 类名.class
InputStream is = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
// 加载配置文件
props.load(is);
//2. 实例化容器 [单例.只创建一次]
beans = new HashMap<String, Object>();
// 2.1 取出配置文件中所有的key
Enumeration<Object> keys = props.keys();
// 2.2 遍历枚举
while (keys.hasMoreElements()) {
// 2.2.1 去除每个key
String key = (String) keys.nextElement();
// 2.2.2 根据key获取值(类的权限定类名)
String beanPath = (String) props.get(key);
// 2.3 反射创建对象
Object value = Class.forName(beanPath).newInstance();
// 2.4 把key和value存入容器中(Map集合)
beans.put(key, value);
}
} catch (Exception e) {
// 错误 error子类
throw new ExceptionInInitializerError("Properties init error !");
}
}
/**
* 改进: Bean只创建一次,(创建的对象存入容器中.此处指Map集合)
*
* @param beanName Bean的名称
* @return Bean的对象
*/
public static Object getBean(String beanName) {
// 根据Bean的名称从容器中获取Bean的对象
return beans.get(beanName);
}
/**
* 根据Bean的名称获取Bean的对象 [此处是多例,每次都创建对象]
*
* @param beanName Bean的名称
* @return Bean的对象
*/
// public static Object getBean(String beanName) {
// Object bean = null;
// try {
// String beanPath = props.getProperty(beanName);
// // 获取Class对象 Class.forName("权限定类名")
// // Constructor创建对象 T newInstance(Object... initargs)
// bean = Class.forName(beanPath).newInstance();
// } catch (Exception e) {
// e.printStackTrace();
// }
// return bean;
// }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
上次更新: 2023/04/09, 20:48:28