- 目标:
- 掌握Spring是什么? 有什么用? ----> 业务层框架,作用:解耦。
- 了解工厂解耦 — 用工厂创建实例对象 , 手动new有什么区别
- 掌握IOC 控制反转
- 掌握DI 依赖注入
- IOC + DI
一、简介
- 什么是Spring
- Spring 是分层的Java SE/EE应用 full-stack(服务端的全栈)轻量级(跟EJB比)开源框架,以IoC(Inversion of Control控制反转,目的是解耦)和AOP(面向切面编程,本质是动态代理)为内核
- Spring家族有很多的框架,涉及到所有层(web |service |dao)
- 今天学的Spring仅仅是Spring家族里面的其中一个框架 Spring Framework (IOC + AOP)
- 提供了:
- 表示层Spring MVC
- 持久层Spring JDBCTemplate, Spring Data JPA
- 业务层事务管理等
- 能整合开源世界众多著名的第三方框架和类库,逐渐成为使用最多的Java EE企业应用开源框架。
- Spring的发展历程
- 1997年,IBM提出了EJB的思想
- 1998年,SUN制定开发标准规范EJB1.0
- 1999年,EJB1.1发布
2001年,EJB2.0发布
2003年,EJB2.1发布
2006年,EJB3.0发布 - Rod Johnson(spring之父)
- Expert One-to-One J2EE Design and Development(2002)
阐述了J2EE使用EJB开发设计的优点及解决方案 - Expert One-to-One J2EE Development without EJB(2004)
阐述了J2EE开发不使用EJB的解决方式(Spring雏形)
- Expert One-to-One J2EE Design and Development(2002)
- 2017年9月份发布了spring的最新版本spring 5.0通用版(GA)
- Spring的优势
- 方便解耦,简化开发(IoC思想,第1、2天)
通过Spring提供的IoC容器,可以将对象间的依赖关系交由Spring进行控制,避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码,可以更专注于上层的应用。 创建对象更简单! - AOP编程的支持(第3天)
通过Spring的AOP功能,方便进行面向切面的编程,许多不容易用传统OOP实现的功能可以通过AOP轻松应付。
比如:要求面面项目里,每个方法被调用时,都输出日志到控制台“2020-03-20 11:20:31执行了xxx.xx方法” - 声明式事务的支持(第3天)
可以将我们从单调烦闷的事务管理代码中解脱出来,通过声明式方式灵活的进行事务的管理,提高开发效率和质量。@Transactional - 方便程序的测试(第1天)
可以用非容器依赖的编程方式进行几乎所有的测试工作,测试不再是昂贵的操作,而是随手可做的事情。
例如:Spring整合了Junit - 方便集成各种优秀框架(SSM整合,SpringMVC第2天)
Spring可以降低各种框架的使用难度,提供了对各种优秀框架(Struts、Hibernate、Hessian、Quartz等)的直接支持。 - 降低JavaEE API的使用难度(第3天)
Spring对JavaEE API(如JDBC、JavaMail、远程调用等)进行了薄薄的封装层,使这些API的使用难度大为降低。 - Java源码是经典学习范例
Spring的源代码设计精妙、结构清晰、匠心独用,处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。它的源代码无疑是Java技术的最佳实践的范例。
- Spring的体系结构
二
、工厂模式解耦(理解)
- 耦合性问题
- 耦合性:程序之间的依赖性。
- 编译期依赖:编译时必须提供依赖的类,否则编译不通过。
- UserDao dao = new UserDaoImpl();
- 运行期依赖:运行时必须提供依赖的类,否则不能运行。
- UserDao dao = Class.forName(“com.itheima.dao.impl.UserDaoImpl”).newInstance();
- 应当减少编译期依赖,使用运行期依赖
- 编译期依赖:编译时必须提供依赖的类,否则编译不通过。
- 耦合性越强,维护成本(时间成本&精力成本)就越高
- 开发时要求:高内聚,低耦合
- 低耦合 : 耦合度很低,代码与代码之间耦合度很低。
- 高内聚: 把具有一样功能的代码,尽可能靠拢起来。 一个业务有很多的方法,这些方法要尽可能靠在一块。方便管理,维护。
类与类之间的内聚- 注册 ---- RegisterServlet
- 登录 — LoginServlet
- 更新用户 — UpdateUserServlet
- 用户 ----- UserServlet
方法与方法之间的内聚
每个方法里面都有乱码解决…两句话 ---- 过滤器。。
1.1 耦合性问题现象
- 在web开发中,服务端通常分为三层:web层、service层、dao层
- web层调用service层完成功能:需要new一个Service对象
- UserService userService = new UserService();
- 真正开发的时候是面向接口编程。
- UserService userService = new UserServiceImpl();
- service层调用dao层操作数据库:需要new一个dao对象
- UserDao userDao = new UserDao();
- 真正开发的时候是面向接口编程。
- UerDao userDao = new UserDaoImpl;
- UserDao userDao = new UserDaoImpl02();
- web层调用service层完成功能:需要new一个Service对象
- 三层之间的耦合性比较强:存在编译期依赖
- service里写死了创建某一个dao对象:一旦dao对象换了,就需要修改service的源码
- web里写死了创建某一个service对象:一旦service对象换了,就需要修改web的源码
1.2 解耦的思路
- 可以使用反射技术,代替new创建对象,避免编译期依赖
Class clazz = Class.forName(“全限定类名”);
Object obj = clazz.newInstance(); - 再把全限定类名提取到配置文件中(xml或properties),读取配置文件信息来反射创建对象
//读取配置文件,得到要创建对象的全限定类名;再通过反射技术创建对象
String className = …;
Class clazz = Class.forName(className);
Object obj = clazz.newInstance();
- 使用工厂模式解耦
需求描述
- UserService提供用户相关的功能,需要调用UserDao完成数据库操作
- 使用工厂模式+配置文件的方式,降低它们之间的耦合性
需求分析
需求实现
- 创建项目,导入依赖
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
2. dao层代码
package com.itheima.dao;
public interface UserDao {
void add();
}
package com.itheima.dao.impl;
import com.itheima.dao.UserDao;
public class UserDaoImpl implements UserDao {
public void add() {
System.out.println("UserDaoImpl...add");
}
}
- service层代码
package com.itheima.service;
public interface UserService {
void add();
}
package com.itheima.service.impl;
import com.itheima.dao.UserDao;
import com.itheima.factory.BeanFactory;
import com.itheima.service.UserService;
public class UserServiceImpl implements UserService {
public void add() {
try {
System.out.println("UserServiceImpl...add..");
//UserService userService = new UserService(); 最早的代码
//有接口的代码
//UserService userService = new UserServiceImpl();
//使用工厂来解耦。
UserDao userDao = (UserDao) BeanFactory.getBean("ud");
userDao.add();
} catch (Exception e) {
e.printStackTrace();
}
}
}
- 配置文件beans.properties
配置文件写在 resources目录面
ud=com.itheima.dao.impl.UserDaoImpl
us=com.itheima.service.impl.UserServiceImpl - 工厂类BeanFactory
package com.itheima.factory;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.ResourceBundle;
public class BeanFactory {
private static Map<String ,String> map = new HashMap<>();
//1. 在静态代码块里面读取配置文件
static {
//1.1 读取resources下面的bean.properties文件
ResourceBundle bundle = ResourceBundle.getBundle("bean");
//1.2 获取文件里面所有key
Enumeration<String> keys = bundle.getKeys();
//1.3 遍历所有的key
while(keys.hasMoreElements()){
String className = keys.nextElement(); // ud
String classPath = bundle.getString(className); // com.itheima.dao.impl.UserDaoImpl
//1.4 把key 和 类的全路径对应关系,使用map来存。
map.put(className , classPath);
}
}
//2. 使用一个方法专门提供实例
public static Object getBean(String beanName) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
//2.1 从map里面取出来类的全路径
String className = map.get(beanName);
//2.2 如果能取出来,表示有,那么就创建实例返回
if(className != null){
return Class.forName(className).newInstance();
}
//2.3 如果没有就返回null
return null;
}
}
小结
-
首先得有接口和实现类 : UserDao 和 UserDaoImplement , UserService 和 UserServiceImpl
-
使用properties配置文件来记录 ,别名和实现类的全路径
-
定义一个工厂类
- 在静态代码块里面读取配置文件,使用map集合来存映射关系
- 定义一个静态方法,只要有人来获取实例,那么就从map集合里面取出来全路径
- 使用反射技术来构建实例返回。
-
IoC思想
- IoC:Inversion of Control,控制反转。是指 把创建对象的控制权交给框架:要想得到一个对象,由原来的主动创建对象,变成自己被动接收 框架创建的对象。
- IoC是Spring的核心思想之一
- 作用:用于降低程序间的耦合性
三、控制反转IoC【重点】
0 . IOC
- 什么是IOC
控制反转,把对象的创建工作交给框架(工厂),我们不需要自己去new这个对象,只管问工厂要。由原来的主动创建对象,变成自己被动接收 框架创建的对象。
- IOC的作用
IOC是Spring的核心之一,作用就是为了解耦,降低程序,代码间的耦合度。
- 快速入门
需求描述
- 有UserDao接口和UserDaoImpl实现类
- 通过Spring容器得到UserDaoImpl的实例对象(IoC方式)
开发步骤
- 创建Maven项目,导入依赖坐标:Spring的依赖坐标
- 编写dao接口UserDao及实现UserDaoImpl
- 创建Spring核心配置文件,并配置UserDaoImpl (作用类似bean.properties)
- 测试:使用Spring的API,获取Bean实例对象
需求实现
- 创建Maven项目,导入依赖坐标
org.springframework spring-context 5.1.2.RELEASE junit junit 4.12 ```
3. 编写dao层和service层代码
- dao层接口UserDao
2. 编写dao层和service层代码
- dao层接口UserDao
package com.itheima.dao;
public interface UserDao {
void add();
}
service层接口UserService
package com.itheima.service;
public interface UserService {
void add();
void delete();
}
service层实现类UserServiceImpl
package com.itheima.service.impl;
import com.itheima.dao.UserDao;
import com.itheima.dao.impl.UserDaoImpl;
import com.itheima.service.UserService;
public class UserServiceImpl implements UserService {
//4. 不想new对象了,想让spring注入进来等号的右边。
//private UserDao userDao = new UserDaoImpl();
//5. 想要让srping完成userDao的赋值工作,就使用一个set方法来完成。
private UserDao userDao;
public void setUserDao(UserDao userDao) {
System.out.println("spring来调用set方法赋值了");
this.userDao = userDao;
}
public void add() {
System.out.println(“userServiceImpl…add…”);
//1. 最早的代码
//UserDao userDao = new UserDao();
//2. 有接口的代码
// UserDao userDao = new UserDaoImpl();
//userDao.add();
//3. 把userDao 提取上去,只要做一个对象即可
userDao.add();
}
public void delete() {
System.out.println("userServiceImpl..delete...");
//2. 有接口的代码
//UserDao userDao = new UserDaoImpl();
//userDao.delete();
}
}
- 创建Spring核心配置文件,并配置bean和依赖注入
<?xml version="1.0" encoding="UTF-8"?>
<!--把两个实现类都交给spring来管理-->
<!--把service交给spring管理,在这个类里面有一个属性叫做userDao 它需要完成赋值的工作,
这个赋值的工作就交给spring来完成,拿谁来赋值? 拿名字叫做ud的bean 来赋值
其实就是拿UserDaoImpl的对象来赋值-->
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
<property name="userDao" ref="ud"/>
</bean>
```
4. 使用Spring的API,测试
package com.itheima.test;
import com.itheima.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestUserService {
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService us = context.getBean("userService" , UserService.class);
us.add();
}
}
小结
2. 三种常见注入方式
set方法注入(最常用)
1) 介绍
在类中提供需要注入的成员(依赖项)的set方法,在配置文件中注入属性的值
```
- property标签:用在bean标签内部,表示要给某一属性注入数据
- name:属性名称
- value:要注入的属性值,注入简单类型值
- ref:要注入的属性值,注入其它bean对象
优势:创建bean对象时没有明确的限制,可以使用无参构造直接创建
缺点:如果某个成员必须有值,则获取对象时,有可能set方法未执行
- 示例
- dao
public class UserDaoImpl02 implements UserDao {
public void add() {
System.out.println("UserDaoImpl02...add");
}
}
service
public class UserServiceImpl02 implements UserService {
//1. 表示UserServiceImpl02 有一个属性|成员
private UserDao userDao ;//= new UserDaoImpl();
private String address;
//2. 提供一个set方法,以便spring完成注入。
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void setAddress(String address) {
this.address = address;
}
public void add() {
System.out.println("UserServiceImpl02..add..." +address);
userDao.add();
}
public void delete() {
System.out.println("UserServiceImpl02..delete...");
}
}
xml
<!--3. 把对象交给spring 来管理-->
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl02"/>
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl02">
<!--
4.给属性注入值
property 指的就是UserServiceImpl02类的一个属性 userDao
ref :引用对象,其实就是使用哪个bean注入进来,要写的是bean的id值-->
<property name="userDao" ref="userDao"/>
<property name="address" value="深圳"/>
</bean>
构造方法注入
- 介绍
在类中提供构造方法,构造方法的每个参数就是一个依赖项,通过构造方法给依赖项注入值。
```
- name:构造参数的名称
- type:构造参数的类型
- index:构造参数的索引
- value:要注入的值,注入简单类型值
- ref:要注入的值,注入其它bean对象
优势:在获取bean对象时,注入数据是必须的操作,否则无法创建成功。
缺点:改变了bean对象的实例化方式,如果在创建对象时用不到这些数据,也必须要提供
- 示例
- dao
public class UserDaoImpl03 implements UserDao {
public void add() {
System.out.println("UserDaoImpl03...add");
}
}
service
public class UserServiceImpl03 implements UserService {
private UserDao userDao;
private String address;
public UserServiceImpl03(){
}
public UserServiceImpl03(UserDao userDao, String address) {
System.out.println("使用有参构造进行赋值");
this.userDao = userDao;
this.address = address;
}
public void add() {
System.out.println("UserServiceImpl03..add..." +address);
userDao.add();
}
public void delete() {
System.out.println("UserServiceImpl03..delete...");
}
}
xml
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl03"/>
<!--默认情况下,spring创建一个类的对象,走的是无参构造。
如果一定要让它走有参构造,去完成依赖注入的功能,也可以-->
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl03">
<constructor-arg name="address" value="北京"/>
<constructor-arg name="userDao" ref="userDao"/>
</bean>
p名称空间注入
- 介绍
p名称空间注入,本质仍然是set方法注入
在xml中引入p名称空间的约束
然后通过p:属性名称="“来注入简单数据、使用p:属性名称-ref=”"注入其它bean对象,它的本质仍然是set方法注入
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="" class="" p:属性名="简单值" p:属性名-ref="bean的id"></bean>
</beans>
- 示例
- dao
public class UserServiceImpl04 implements UserService {
private UserDao userDao;
private String address;
//使用p名称空间方式来注入 ,背后使用的还是set方法。所以还是要提供set方法
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void setAddress(String address) {
this.address = address;
}
public void add() {
System.out.println("UserServiceImpl04..add..." +address);
userDao.add();
}
public void delete() {
System.out.println("UserServiceImpl04..delete...");
}
}
xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl04"/>
<!-- p名称空间的注入写法,背后其实还是走set方法
如果是这个属性要的是普通的值:p:属性名=""
如果这个属性要的是对象类型: p:属性名-ref=""-->
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl04" p:address="深圳湾2号" p:userDao-ref="userDao"/>
</beans>
小结
-
注入方式有三种,set方法 ,构造方法注入,p名称空间
-
最常用的是set方法。
-
以后如果使用注解了,方法也不需要写了。
-
注入集合数据
介绍
- 前边我们介绍了如何注入简单数据类型和bean对象,但是在实际开发中,可能会需要给集合属性注入数据,比如:给数组、List、Set、Map等注入数据
示例
有UserDaoImpl需要注入数据
public class UserDaoImpl implements UserDao {
private String[] arr;
private List<String> list;
private Set<String> set;
private Map<String,String> map;
private Properties properties;
// get/set...
public void show(){
System.out.println(Arrays.toString(this.arr));
System.out.println(this.list);
System.out.println(this.set);
System.out.println(this.map);
System.out.println(this.properties);
}
}
配置注入数据
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
<!--给数组注入数据-->
<property name="arr">
<array>
<value>a</value>
<value>b</value>
<value>c</value>
</array>
</property>
<!--给list注入数据-->
<property name="list">
<list>
<value>a1</value>
<value>b1</value>
<value>c1</value>
</list>
</property>
<!--给set注入数据-->
<property name="set">
<set>
<value>a2</value>
<value>b2</value>
<value>c2</value>
</set>
</property>
<!--给map注入数据-->
<property name="map">
<map>
<entry key="a3" value="a3"/>
<entry key="b3" value="b3"/>
<entry key="c3" value="c3"/>
</map>
</property>
<!--给properties注入数据-->
<property name="properties">
<props>
<prop key="a4">a4</prop>
<prop key="b4">b4</prop>
<prop key="c4">c4</prop>
</props>
</property>
</bean>
总结
- spring的IOC & DI
- 什么是spring
- 是业务逻辑层的一套框架,能够无缝对接|整合web层和dao层其他框架,它的核心是IOC 和 AOP。
- 什么时候IOC
- 控制反转, 就是把类交给spring托管,让spring创建这个类的对象
- Spring创建对象的时候,默认执行的是类的无参构造,当然也可以让它走有参构造。
- 控制反转, 就是把类交给spring托管,让spring创建这个类的对象
- DI
- 什么是DI
- 依赖注入,把属性需要用到的对象赋值|注入进来。
- 注入的方式
- 三种方式: set方式 | 构造方式 | p名称空间(背后也是set)
- 依赖注入,最常用的是注入对象类型,使用set方法。
- 什么是DI
- crud
- 整合dbutils
- 整合c3p0
- spring整合Junit
- 在做单元测试的时候,获取bean的时候更加简单。