1. Spring
1.1 简介
- 2002年,首次推出了Spring框架的雏形:interface21框架
- Spring框架即以interface21框架为基础,经过重新设计,并不断丰富其内涵,于2004年3月24日发布了1.0正式版
- Rod Johnson,Spring Framework创始人,著名作者
- Spring理念:使得现有的技术更加容易使用,本身是一个大杂烩,整合了现有的技术框架
官网地址:https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#spring-core
官方下载地址:https://repo.spring.io/ui/native/release/org/springframework/spring
GitHub地址:https://github.com/spring-projects/spring-framework
Maven仓库:
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.18</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.18</version>
</dependency>
1.2 优点
- Spring是一个开源的免费的框架(容器)
- Spring是一个轻量级的,非入侵式的框架
- 控制反转(IOC),面向切面编程(AOP)
- 支持事务的处理,对框架整合的支持
总结起来就一句话,Spring是一个轻量级的控制反转(IOC)和面向切面编程(AOP)的框架
1.3 组成
1.4 拓展
在Spring的官网中有这个介绍:现代化的Java开发,说白就是基于Spring的开发
- SpringBoot
- 一个快速开发的脚手架
- 基于SpringBoot可以快速地开发单个微服务
- 约定大于配置
- SpringCloud
- SpringCloud是基于SpringBoot实现的
弊端:发展太久之后,违背了原来的理念,配置十分繁琐,人称:”配置地狱“
2. IOC理论推导
- UserDao接口
- UserDaoImpl实现类
- UserService接口
- UserServiceImpl实现类
在我们之前的业务中,用户的需求可能会影响我们原来的代码,我们需要根据用户的需求去修改原代码!如果程序代码量十分大,修改一次的成本代价十分昂贵
我们使用一个Set接口实现,已经发生了革命性的变化
private UserDao userDao;
//利用set进行动态实现值的注入
public void setUserDao(UserDao userDao){
this.userDao=userDao;
}
- 之前,程序是主动创建对象,控制权在程序员手上
- 使用了Set注入后,程序不再具有主动性,而是变成了被动的接受对象
这种思想,从本质上解决了问题,我们程序员不用再去管理对象的创建了,系统的耦合性大大降低了,可以更加专注业务的实现,这就是IOC的原型
UserDao接口
package com.jian.service;
public interface UserDao {
void getUser();
}
UserDaoImpl和OracleUserDaoImpl实现类
package com.jian.dao;
public class UserDaoImpl implements UserDao{
@Override
public void getUser() {
System.out.println("UserDao获取用户信息");
}
}
package com.jian.dao;
public class OracleUserDaoImpl implements UserDao{
@Override
public void getUser() {
System.out.println("Oracle中获取用户信息");
}
}
UserService接口和UserServiceImpl实现类
package com.jian.service;
public interface UserService {
void getUser();
}
package com.jian.service;
import com.jian.dao.UserDao;
public class UserServiceImpl implements UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@Override
public void getUser() {
userDao.getUser();
}
}
Test.java
import com.jian.dao.OracleUserDaoImpl;
import com.jian.dao.UserDaoImpl;
import com.jian.service.UserService;
import com.jian.service.UserServiceImpl;
import org.junit.Test;
public class MyTest {
@Test
public void test(){
UserService userService=new UserServiceImpl();
((UserServiceImpl) userService).setUserDao(new OracleUserDaoImpl());
userService.getUser();
}
}
2.1 IOC本质
控制反转(Inversion of Control),是一种设计思想,DI(依赖注入)是实现IOC的一种方法,也有人认为DI只是IOC的另外一种说法,没有IOC的程序中,我们使用面向对象编程,对象的创建于对象之间的依赖关系完全硬编码在程序中,对象的创建由程序自己控制,控制反转后将对象的创建转移给第三方,个人认为所谓控制反转就是:获得依赖的对象的方式反转了
采用XML方式配置Bean的时候,Bean的定义信息是和实现分离的,而采用注解的方式可以把两者合为一体,Bean的定义信息直接以注解的形式定义在实现类中,从而达到了零配置的目的
控制反转是一种通过描述(XML或注解),并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IOC容器,其实现方法是依赖注入(Dependency Injection,DI)
3. HelloSpring
pojo/Hello
package com.jian.pojo;
public class Hello {
private String str;
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
@Override
public String toString() {
return "Hello{" +
"str='" + str + '\'' +
'}';
}
}
resources/beans.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--
Use Spring to create these Object,these Objects are named Bean
类型 变量名 = new 类型();
Hello hello = new Hello();
id=变量名
class=new 的对象
property相当于给对象的属性设置一个值!
-->
<bean id="hello" class="com.jian.pojo.Hello">
<property name="str" value="Spring"/>
</bean>
</beans>
test/MyTest
import com.jian.pojo.Hello;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
@Test
public void test(){
//获取Spring的上下文对象
ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
//我们的对象现在都在Spring中管理了,我们要使用,直接从里面取出来即可
Hello hello = (Hello) context.getBean("hello");
System.out.println(hello.toString());
}
}
我们彻底不用到程序中去改动了,要实现不同的操作,只需要在xml配置文件中进行修改,所谓IOC,一句话搞定:对象由Spring来创建,管理,装配
4.IOC创建对象的方式
- 使用无参构造函数创建对象,默认!
- 假设我们要使用有参构造创建对象
- 第一种方法:下标赋值
- 第二种方法:通过类型
- 第三种方法:直接通过参数名
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--第一种、下标赋值-->
<bean id="user" class="com.jian.pojo.User">
<constructor-arg index="0" value="Json"/>
</bean>
<!--第二种、通过类型创建,不建议使用,因为参数可能类型相同-->
<bean id="user2" class="com.jian.pojo.User">
<constructor-arg type="java.lang.String" value="Bob"/>
</bean>
<!--第三种、通过参数名创建-->
<bean id="user3" class="com.jian.pojo.User">
<constructor-arg name="name" value="Lisa"/>
</bean>
</beans>
总结:在配置文件加载的时候,容器中管理的对象就已经初始化了!
5. Spring配置
5.1 别名
<!--第三种、通过参数名创建-->
<bean id="user3" class="com.jian.pojo.User">
<constructor-arg name="name" value="Lisa"/>
</bean>
<!--如果取了别名,也可以使用别名获取到这个对象-->
<alias name="user3" alias="userW"/>
import com.jian.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
@Test
public void test(){
ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
User user = (User) context.getBean("userW");
user.show();
}
}
5.2 Bean配置
<!--
Bean的配置
id:bean的唯一标识符,也就是相当于我们学的对象名
class:bean对象对应的全限定名:包名+类名
name:也是别名,而且name可以取多个别名,用逗号,空格,分号隔开
-->
<bean id="user4" class="com.jian.pojo.User" name="userF u1">
<constructor-arg name="name" value="Andy"/>
</bean>
5.3 Import
这个import,一般用于团队开发使用,他可以将多个配置文件,导入合并为一个
假设,现在项目中有多个人开发,这三个人复制不同的类开发,不同的类需要注册在不同的bean中,我们可以利用import将所有人的beans.xml合并为一个总的
- beans1.xml
- beans2.xml
- beans3.xml
- applicationContext.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<import resource="beans.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>
</beans>
使用的时候,直接使用总的配置就可以了
6. 依赖注入
6.1 构造器注入
见4
6.2 Set方式注入【重点】
- 依赖注入:Set注入
- 依赖:bean对象的创建依赖于容器
- 注入:bean对象中的所有属性,由容器来注入
【环境搭建】
-
复杂类型
package com.jian.pojo; public class Address { private String address; public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } }
-
真实测试对象
package com.jian.pojo; import java.util.*; public class Student { private String name; private Address address; private String[] books; private List<String> hobbies; private Map<String,String> card; private Set<String> games; private String wife; private Properties info; public String getName() { return name; } public void setName(String name) { this.name = name; } public Address getAddress() { return address; } public void setAddress(Address address) { this.address = address; } public String[] getBooks() { return books; } public void setBooks(String[] books) { this.books = books; } public List<String> getHobbies() { return hobbies; } public void setHobbies(List<String> hobbies) { this.hobbies = hobbies; } public Map<String, String> getCard() { return card; } public void setCard(Map<String, String> card) { this.card = card; } public Set<String> getGames() { return games; } public void setGames(Set<String> games) { this.games = games; } public String getWife() { return wife; } public void setWife(String wife) { this.wife = wife; } public Properties getInfo() { return info; } public void setInfo(Properties info) { this.info = info; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", address=" + address + ", books=" + Arrays.toString(books) + ", hobbies=" + hobbies + ", card=" + card + ", games=" + games + ", wife='" + wife + '\'' + ", info=" + info + '}'; } }
-
Beans.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" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="address" class="com.jian.pojo.Address"> <property name="address" value="南昌"/> </bean> <bean id="student" class="com.jian.pojo.Student"> <!--第一种,普通值注入,value--> <property name="name" value="Json"/> <!--第二种,Bean注入,ref--> <property name="address" ref="address"/> <!--第三种,数组注入--> <property name="books"> <array> <value>三国演义</value> <value>红楼梦</value> <value>水浒传</value> <value>西游记</value> </array> </property> <!--第四种,List注入--> <property name="hobbies"> <list> <value>看电影</value> <value>听音乐</value> <value>做运动</value> </list> </property> <!--第五种,Map注入--> <property name="card"> <map> <entry key="身份证" value="111111"/> <entry key="银行卡" value="666666"/> </map> </property> <!--第六种,Set注入--> <property name="games"> <set> <value>篮球</value> <value>乒乓球</value> <value>羽毛球</value> </set> </property> <!--第七种,null--> <property name="wife"> <null/> </property> <!--第八种,Properties--> <property name="info"> <props> <prop key="name">Bob</prop> <prop key="sex">男</prop> </props> </property> </bean> </beans>
-
Test.java
import com.jian.pojo.Student; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class MyTest { @Test public void test(){ ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml"); Student student = (Student) context.getBean("student"); System.out.println(student); } }
6.3 拓展方式注入
我们可以使用p命名空间和c命名空间进行注入
官方解释:
使用beans.xml:
<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"
xmlns:c="http://www.springframework.org/schema/c"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--p命名空间注入,可以直接注入属性的值:property-->
<bean id="user" class="com.jian.pojo.User" p:name="海王" p:age="18"/>
<!--c命名空间注入,通过构造器注入:constructor-args-->
<bean id="userT" class="com.jian.pojo.User" c:name="Json" c:age="22"/>
</beans>
测试:
@Test
public void test2(){
ApplicationContext context=new ClassPathXmlApplicationContext("userbeans.xml");
User user = context.getBean("userT", User.class);
System.out.println(user);
}
注意点:p命名和c命名空间不能直接使用,需要导入xml的约束
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
6.4 Bean的作用域
-
单例模式(Spring的默认机制)
<!--c命名空间注入,通过构造器注入:constructor-args--> <bean id="userT" class="com.jian.pojo.User" c:name="Json" c:age="22" scope="singleton"/>
-
原型模式:每次从容器中get的时候,都会产生一个新对象
<!--c命名空间注入,通过构造器注入:constructor-args--> <bean id="userT" class="com.jian.pojo.User" c:name="Json" c:age="22" scope="prototype"/>
-
其余的request、session、application这些只能在web开发中使用到
7. Bean的自动装配
- 自动装配是Spring满足bean依赖的一种方式
- Spring会在上下文中自动寻找,并自动给bean装配属性
在Spring中有三种装配的方式
- 在xml中显式的配置
- 在java中显式配置
- 隐式的自动装配bean【重要】
7.1 测试
- 搭建环境
- 一个人有两个宠物
package com.jian.pojo;
public class People {
private String name;
private Dog dog;
private Cat cat;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}
public Cat getCat() {
return cat;
}
public void setCat(Cat cat) {
this.cat = cat;
}
@Override
public String toString() {
return "People{" +
"name='" + name + '\'' +
", dog=" + dog +
", cat=" + cat +
'}';
}
}
7.2 ByName自动装配
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="dog" class="com.jian.pojo.Dog"/>
<bean id="cat" class="com.jian.pojo.Cat"/>
<!--ByName会自动在容器上下文中查找,和自己对象Set方法后面的名对应的beanId-->
<bean id="people" class="com.jian.pojo.People" autowire="byName">
<property name="name" value="海王"/>
</bean>
</beans>
7.3 ByType自动装配
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="dog" class="com.jian.pojo.Dog"/>
<bean id="cat" class="com.jian.pojo.Cat"/>
<!--ByType会自动在容器上下文中查找,和自己对象属性类型相同的Bean-->
<bean id="peopleT" class="com.jian.pojo.People" autowire="byType">
<property name="name" value="强森"/>
</bean>
</beans>
小结:
- ByName的时候,需要保证所有的bean的id唯一,并且这个bean需要和自动注入的属性的set方法后名字一致
- ByType的时候,需要保证所有bean的class唯一,并且这个bean需要和自动注入的属性类型一致
7.4 使用注解实现自动装配
jdk1.5后支持注解,spring2.5后支持注解
使用注解须知:
-
导入约束,contex约束:
xmlns:context="http://www.springframework.org/schema/context"
-
配置注解支持:
<context:annotation-config/>
<?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:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <context:annotation-config/> </beans>
@Autowired
- 直接在属性上使用即可,也可以在set方法上使用
- 使用Autowired我们可以不用编写Set方法了,前提是你这个自动装配的属性在IOC容器中存在,且符合类型跟属性一致byType
科普:
@Nullable 字段标记了这个注解,说明这个字段可以为null
测试代码
package com.jian.pojo;
import org.springframework.beans.factory.annotation.Autowired;
public class People {
private String name;
//如果显式定义了Autowired的required属性为false,说明这个对象可以为null,否则不允许为空
@Autowired(required = false)
private Dog dog;
@Autowired
private Cat cat;
}
如果@Autowired自动装配的环境比较复杂,自动装配无法通过一个注解【@Autowired】完成的时候,我们可以使用@Qualifier(value=“xxx”)去配置@Autowired的使用,指定一个唯一的bean对象注入
beans.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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<context:annotation-config/>
<bean id="dogO" class="com.jian.pojo.Dog"/>
<bean id="dogT" class="com.jian.pojo.Dog"/>
<bean id="catO" class="com.jian.pojo.Cat"/>
<bean id="catT" class="com.jian.pojo.Cat"/>
<bean id="people" class="com.jian.pojo.People"/>
</beans>
People.java(@Autowired和@Qualifier注解)
package com.jian.pojo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
public class People {
private String name;
@Autowired
@Qualifier(value = "dogO")
private Dog dog;
@Autowired
@Qualifier("catT")
private Cat cat;
}
java中的Resource注解
package com.jian.pojo;
import javax.annotation.Resource;
public class People {
private String name;
@Resource(name = "dogT")
private Dog dog;
}
小结
@Resource和@Autowired的区别
- 都是用来自动装配的,都可以放在属性字段上
- @Autowired默认先通过byType的方式实现,而且必须要求这个对象存在【常用】
- @Resouce默认先通过byName的方式实现,如果找不到name,则通过byType实现,又如果多个bean的type相同,则报错【常用】
- 执行顺序不同:@Autowired通过byType的方式实现
8. 使用注解开发
在spring4之后,要使用注解开发,必须要保证aop的包导入了
使用注解需要导入context约束,增加注解的支持
<?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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--指定要扫描的包,这个包下的注解就会生效,这个注解包含下面注解-->
<context:component-scan base-package="com.jian.pojo"/>
<context:annotation-config/>
</beans>
-
bean:@Component
package com.jian.pojo; import org.springframework.stereotype.Component; //@Component等价于<bean id="user" class="com.jian.pojo.User"/> //@Component @Component public class User { public String name="海王星"; }
-
属性如何注入:@Value可以放在属性上,也可以放在set方法上
package com.jian.pojo; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Component; //@Component等价于<bean id="user" class="com.jian.pojo.User"/> //@Component @Component public class User { public String name; //@Value()等价于<property name="name" value="海王"/> @Value("海王") public void setName(String name){ this.name=name; } }
-
衍生的注解
@Component有几个衍生注解,我们在web开发中,会按照mvc三层架构分层
- dao【@Repository】
- service【@Service】
- controller【@Controller】
这四个注解功能都是一样的,都是代表将某个类注册到Spring中,装配Bean
-
自动装配注解
@Autowired:自动装配通过类型、名字 如果Autowired不能唯一自动装配上属性,则需要通过@Qualifier(value="") @Nullable 字段标记了这个注解,说明这个字段可以为null @Resource 自动装配通过名字、类型
-
作用域(Scope)
package com.jian.pojo; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Component; //@Component等价于<bean id="user" class="com.jian.pojo.User"/> //@Component @Component @Scope("prototype") public class User { public String name; //@Value()等价于<property name="name" value="海王"/> @Value("海王") public void setName(String name){ this.name=name; } }
-
小结
xml与注解:
- xml更加万能,适用于任何场合,维护简单方便
- 注解不是自己的类使用不了,维护相对复杂
xml与注解的最佳实践:
-
xml用来管理bean
-
注解只负责完成属性的注入
-
我们在使用过程中,只需要注意一个问题:必须让注解生效,就需要开启注解的支持
<?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:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <!--指定要扫描的包,这个包下的注解就会生效--> <context:component-scan base-package="com.jian"/> <context:annotation-config/> </beans>
9. 使用Java的方式配置Spring
我们现在要完全不使用Spring的xml配置了,全权交给Java来做
JavaConfig是Spring的一个子项目,在Spring4之后,它成为了一个核心功能!
实体类
package com.jian.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class User {
@Value("JQuery")
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
配置类
package com.jian.config;
import com.jian.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
//@Configuration这个也会被Spring容器托管,注册到容器中,因为它本来就是一个@Component
//@Configuration代表这是一个配置类,就和我们之前看到beans.xml一样
@Configuration
@ComponentScan("com.jian.pojo") //等价于<context:component-scan base-package="com.jian.pojo"/>
@Import(AppConfigT.class) //等价于<import resource=""/>
public class AppConfig {
//@Bean 注册一个Bean,就相当于我们之前写的一个bean标签
//方法名相当于bean中id值
//返回值类型相当于bean中的class
@Bean
public User getUser(){
return new User(); //返回要注入到bean中的对象
}
}
测试类
import com.jian.config.AppConfig;
import com.jian.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class MyTest {
@Test
public void test(){
//如果完全使用了配置类的方式去做,我们只能通过AnnotationConfig上下文来获取容器,通过配置类的class对象加载
ApplicationContext context=new AnnotationConfigApplicationContext(AppConfig.class);
User getUser = context.getBean("user", User.class);
System.out.println(getUser.getName());
}
}
10. 代理模式
为什么要学习代理模式?因为这是spring中AOP的底层
代理模式的分类:
- 静态代理
- 动态代理
10.1 静态代理
角色分析:
-
抽象角色:一般会使用接口或抽象类来解决
package com.jian.demo01; public interface Rent { void rent(); }
-
真实角色:被代理的角色
package com.jian.demo01; public class Landlord implements Rent{ @Override public void rent() { System.out.println("房东要出租房子啦!"); } }
-
代理角色:代理真实角色,代理真实角色后,我们一般会做一些附属操作\
package com.jian.demo01; public class Proxy implements Rent{ private Landlord landlord; public Proxy(){} public Proxy(Landlord landlord){ this.landlord=landlord; } @Override public void rent() { seeHouse(); landlord.rent(); fee(); contract(); } public void fee(){ System.out.println("中介收取中介费!"); } public void seeHouse(){ System.out.println("中介带你看房子!"); } public void contract(){ System.out.println("中介跟你签订租赁合同!"); } }
-
客户:访问代理对象的人
package com.jian.demo01; import org.junit.Test; public class Client { @Test public void rentHouse(){ //房东要出租房子,找中介代理 Landlord landlord=new Landlord(); //代理,中介帮房东出租房子,但是中介一般还会有一些附属操作 Proxy proxy=new Proxy(landlord); proxy.rent(); } }
代理模式的好处:
- 可以使真实角色的操作更加纯粹,不用再去关注一些公共的业务
- 公共业务交给代理角色,实现了业务的分工
- 公共业务发生扩展的时候,方便集中管理
缺点:
- 一个真实角色就会产生一个代理角色,代码量会翻倍,开发效率会降低
10.2 静态代理模式加深理解
-
抽象角色
package com.jian.demo02; public interface UserService { void add(); void delete(); void update(); void query(); }
-
真实角色
package com.jian.demo02; public class UserServiceImpl implements UserService{ @Override public void add() { System.out.println("增加一条记录"); } @Override public void delete() { System.out.println("删除一条记录"); } @Override public void update() { System.out.println("修改一条记录"); } @Override public void query() { System.out.println("查询一条记录"); } }
-
代理角色
package com.jian.demo02; public class UserServiceImplProxy implements UserService { private UserService userService; public void setUserService(UserService userService) { this.userService = userService; } @Override public void add() { log("add"); userService.add(); } @Override public void delete() { log("delete"); userService.delete(); } @Override public void update() { log("update"); userService.update(); } @Override public void query() { log("query"); userService.query(); } public void log(String msg) { System.out.println("调用了" + msg + "方法!"); } }
-
客户
package com.jian.demo02; import org.junit.Test; public class Client { @Test public void test(){ UserServiceImpl userService=new UserServiceImpl(); UserServiceImplProxy userIP=new UserServiceImplProxy(); userIP.setUserService(userService); userIP.add(); } }
10.3 动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成得到,不是我们直接写好的
- 动态代理分为两大类:基于接口的动态代理,基于类的动态代理
- 基于接口–JDK的动态代理【我们这里使用】
- 基于类:cglib
- java字节码实现:javasist
需要了解两个类:Proxy:代理、InvocationHandler:调用处理程序
抽象角色
package com.jian.demo02;
public interface UserService {
void add();
void delete();
void update();
void query();
}
真实角色
package com.jian.demo02;
public class UserServiceImpl implements UserService{
@Override
public void add() {
System.out.println("增加一条记录");
}
@Override
public void delete() {
System.out.println("删除一条记录");
}
@Override
public void update() {
System.out.println("修改一条记录");
}
@Override
public void query() {
System.out.println("查询一条记录");
}
}
代理角色
package com.jian.demo04;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyInvocationHandler implements InvocationHandler {
private Object target;
public void setTarget(Object target) {
this.target = target;
}
public Object getProxy() {
return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
log(method.getName());
Object result = method.invoke(target, args);
return result;
}
public void log(String msg){
System.out.println("调用了"+msg+"方法!");
}
}
客户
package com.jian.demo04;
import com.jian.demo02.UserService;
import com.jian.demo02.UserServiceImpl;
import org.junit.Test;
public class Client {
@Test
public void test() {
//真实对象
UserServiceImpl userService = new UserServiceImpl();
ProxyInvocationHandler pih = new ProxyInvocationHandler();
pih.setTarget(userService); //设置要代理的对象
UserService proxy = (UserService) pih.getProxy(); //动态生成代理类
proxy.query();
}
}
动态代理的好处:
- 可以使真实角色的操作更加纯粹,不用再去关注一些公共的业务
- 公共业务交给代理角色,实现了业务的分工
- 公共业务发生扩展的时候,方便集中管理
- 一个动态代理类代理的是一个接口,一般就是对应的一类业务
- 一个动态代理类可以代理多个类,只要是实现了同一个接口即可!
11. AOP
11.1 什么是AOP
AOP(Aspect Oriented Programming)意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术,AOP是OOP的延续,是软件开发中的一个热点,也是spring框架中的一个重要内容,是函数式编程的一种衍生泛型,利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合降低,提高程序的可重用性,同时提高开发的效率
11.2 AOP在Spring中的作用
提供声明式事务,允许用户自定义切面
-
横切关注点:跨越应用程序多个模块的方法或功能,即是,与我们业务逻辑无关的,但是我们需要关注的部分,就是横切关注点,如日志、安全、缓存、事务等待
-
切面(ASPECT):横切关注点被模块化的特殊对象,即它是一个类
-
通知(Advice):切面必须要完成的工作,即它是类中的一个方法
-
目标(Target):被通知对象
-
代理(Proxy):向目标对象应用通知之后创建的对象
-
切入点(PointCut):切面通知执行的“地点”定义
-
连接点(JointPoint):与切入点匹配的执行点
SpringAop中,通过Advice定义横切逻辑,Spring中支持5种类型的Advice
即AOP在不改变原有代码的情况下,去增加新的功能
11.3 使用Spring实现AOP
【重点】使用AOP织入,需要导入一个依赖包
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.9.1</version>
</dependency>
项目结构图:
方式一:使用原生SpringAPI接口
service/UserService
package com.jian.service;
public interface UserService {
void add();
void delete();
void update();
void select();
}
service/UserServiceImpl
package com.jian.service;
public class UserServiceImpl implements UserService{
@Override
public void add() {
System.out.println("增加一条记录");
}
@Override
public void delete() {
System.out.println("删除一条记录");
}
@Override
public void update() {
System.out.println("修改一条记录");
}
@Override
public void select() {
System.out.println("查询一条记录");
}
}
log/Log
package com.jian.log;
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
public class Log implements MethodBeforeAdvice {
/*
method:要执行目标对象的方法
args:参数
target:目标对象
*/
@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println(target.getClass().getName() + "的" + method.getName() + "方法被执行了!");
}
}
log/AfterLog
package com.jian.log;
import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
public class AfterLog implements AfterReturningAdvice {
//returnValue返回值
@Override
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println(method.getName()+"被执行了,返回值为"+returnValue);
}
}
resources/applicationContext.xml
注意引入aop约束
<?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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--注册bean-->
<bean id="userService" class="com.jian.service.UserServiceImpl"/>
<bean id="log" class="com.jian.log.Log"/>
<bean id="afterLog" class="com.jian.log.AfterLog"/>
<!--方式一:使用原生SpringAPI接口-->
<!--配置aop,需要导入aop的约束-->
<aop:config>
<!--切入点:expression:表达式,execution(要执行的位置****)-->
<aop:pointcut id="pointcut" expression="execution(* com.jian.service.UserServiceImpl.*(..))"/>
<!--执行环绕增加-->
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>
</beans>
测试
import com.jian.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
@Test
public void test(){
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
//注意点:动态代理的是接口
UserService userService = (UserService) context.getBean("userService");
userService.add();
}
}
方式二,通过自定义类实现AOP
其他类同上,除applicationContext.xml,额外自定义一个类diy/DiyPoint
diy/DiyPoint
package com.jian.diy;
public class DiyPoint {
public void before() {
System.out.println("===========方法执行前执行==============");
}
public void after() {
System.out.println("===========方法执行后执行==============");
}
}
resources/applicationContext.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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--注册bean-->
<bean id="userService" class="com.jian.service.UserServiceImpl"/>
<bean id="log" class="com.jian.log.Log"/>
<bean id="afterLog" class="com.jian.log.AfterLog"/>
<!--方式一:使用原生SpringAPI接口-->
<!--配置aop,需要导入aop的约束-->
<!-- <aop:config>-->
<!-- <!–切入点:expression:表达式,execution(要执行的位置****)–>-->
<!-- <aop:pointcut id="pointcut" expression="execution(* com.jian.service.UserServiceImpl.*(..))"/>-->
<!-- <!–执行环绕增加–>-->
<!-- <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>-->
<!-- <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>-->
<!-- </aop:config>-->
<!--方式二:通过自定义类实现-->
<bean id="diy" class="com.jian.diy.DiyPoint"/>
<aop:config>
<aop:aspect ref="diy">
<aop:pointcut id="point" expression="execution(* com.jian.service.UserServiceImpl.*(..))"/>
<aop:before method="before" pointcut-ref="point"/>
<aop:after method="after" pointcut-ref="point"/>
</aop:aspect>
</aop:config>
</beans>
方式三:通过注解@Aspect实现AOP
diy/AnnotationPointCut增强类
package com.jian.diy;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect //标注这个类是一个切面
public class AnnotationPointCut {
@Before("execution(* com.jian.service.UserServiceImpl.*(..))")
public void before() {
System.out.println("========方法执行前=========");
}
@After("execution(* com.jian.service.UserServiceImpl.*(..))")
public void after() {
System.out.println("========方法执行后=========");
}
//在环绕增强中,我们可以给定一个参数,代表我们要获取处理切入的点
@Around("execution(* com.jian.service.UserServiceImpl.*(..))")
public void around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("环绕前");
Signature signature = joinPoint.getSignature(); //获得前面,获得UserServiceImpl中的方法名
System.out.println("signature:"+signature);
Object proceed = joinPoint.proceed(); //执行方法,UserServiceImpl中的方法
System.out.println("环绕后");
}
}
resources/applicationContext.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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--注册bean-->
<bean id="userService" class="com.jian.service.UserServiceImpl"/>
<!--注册bean,如果这里不注册,可在类中使用@Configuration注解-->
<bean id="annotationPointCut" class="com.jian.diy.AnnotationPointCut"/>
<!--开启注解支持,支持切面@Aspect注解-->
<aop:aspectj-autoproxy/>
</beans>
先注册bean
后注解支持:<aop:aspectj-autoproxy/>
测试类同上
结果
小说明
通过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean创建代理,织入切面。当然,spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作,但具体实现的细节已经被<aop:aspectj-autoproxy />隐藏起来了
<aop:aspectj-autoproxy />有一个proxy-target-class属性,默认为false,表示使用jdk动态代理织入增强,当配为<aop:aspectj-autoproxy poxy-target-class="true"/>时,表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false,如果目标类没有声明接口,则spring将自动使用CGLib动态代理。
12. 整合MyBatis
步骤:
-
导入相关jar包
-
junit
<dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> </dependency>
-
mybatis
<dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.9</version> </dependency>
-
mysql数据库
<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.28</version> </dependency>
-
spring相关的
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.3.18</version> </dependency>
-
aop织入
<dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.9.1</version> <scope>runtime</scope> </dependency>
-
spring-jdbc【spring操作数据库】
<!--Spring操作数据库所需要的包,spring-jdbc--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.3.18</version> </dependency>
-
mybatis-spring【new】
<dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.7</version> </dependency>
-
-
编写配置文件
-
测试
12.1 回顾MyBatis
pojo/Users
package com.jian.pojo;
import lombok.Data;
import java.util.Date;
@Data
public class User {
private int id;
private String name;
private String password;
private Date birthday;
private String email;
}
resources/mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<typeAliases>
<package name="com.jian.pojo"/>
</typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url"
value="jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&useSSL=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<mappers>
<package name="com.jian.mapper"/>
</mappers>
</configuration>
mapper/UserMapper
package com.jian.mapper;
import com.jian.pojo.User;
import java.util.List;
public interface UserMapper {
List<User> getUsers();
}
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jian.mapper.UserMapper">
<select id="getUsers" resultType="user">
select *
from users
</select>
</mapper>
utils/MybatisUtils
package com.jian.utils;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
public class MybatisUtils {
private static SqlSessionFactory sqlSessionFactory;
static {
String resources = "mybatis-config.xml";
try {
InputStream is = Resources.getResourceAsStream(resources);
sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
} catch (IOException e) {
e.printStackTrace();
}
}
public static SqlSession getSqlSession() {
return sqlSessionFactory.openSession(true);
}
}
测试类
import com.jian.mapper.UserMapper;
import com.jian.pojo.User;
import com.jian.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;
public class MyTest {
@Test
public void test(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> users = mapper.getUsers();
for (User user : users) {
System.out.println(user);
}
sqlSession.close();
}
}
12.2 Mybatis-Spring
MyBatis-Spring需要用到的包
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.7</version>
</dependency>
<!--Spring操作数据库所需要的包,spring-jdbc-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.18</version>
</dependency>
mybatis-spring文档
https://www.mybatis.org/spring/zh/index.html
什么是MyBatis-Spring
MyBatis-Spring会帮助我们将MyBatis代码无缝地整合到Spring中
实体类同上12.1
新增一个spring-dao.xml,整合mybatis-config.xml
<?xml version="1.0" encoding="UTF8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--
DataSource:使用Spring的数据源替换MyBatis的配置 c3p0 dbcp druid
我们这里使用spring提供的JDBC:org.springframework.jdbc.datasource
-->
<bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url"
value="jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&useSSL=true&characterEncoding=utf-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</bean>
<!--sqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="datasource"/>
<!--绑定MyBatis配置文件-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:com/jian/mapper/*.xml"/>
</bean>
<!--sqlSessionTemplate就相当于我们在MyBatis中使用的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--因为它没有set方法,所以只能用构造器注入-->
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
</beans>
在基础的MyBatis用法中,我们是使用SqlSessionFactoryBuilder来创建SqlSessionFactory对象SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream)
,在Mybatis-Spring中,我们使用SqlSessionFactoryBean来创建
<bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url"
value="jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&useSSL=true&characterEncoding=utf-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</bean>
<!--sqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="datasource"/>
<!--绑定MyBatis配置文件-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:com/jian/mapper/*.xml"/>
</bean>
SqlSessionFactoryBean中有一个唯一必要的属性:<property name="dataSource" ref="datasource"/>
,用户JDBC的DataSource连接,这可以是任意的DataSource对象,它的配置方法和其它Spring数据库连接是一样的
此外,在SqlSessionFactoryBean中还可以绑定Mybatis的核心配置文件<property name="configLocation" value="classpath:mybatis-config.xml"/>
,同时可以注册mapper.xml:<property name="mapperLocations" value="classpath:com/jian/mapper/*.xml"/>
,当然也可以设置别名等等,结果就使得MyBatis核心配置文件并不需要完整的,<environments>
以及<mappers></mappers>
等都可以被省略,最好保留<typeAlias>
和<settings>
<!--sqlSessionTemplate就相当于我们在MyBatis中使用的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--因为它没有set方法,所以只能用构造器注入-->
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
SqlSessionTemplate 是 MyBatis-Spring 的核心。作为 SqlSession 的一个实现,这意味着可以使用它无缝代替你代码中已经在使用的 SqlSession。
模板可以参与到 Spring 的事务管理中,并且由于其是线程安全的,可以供多个映射器类使用,你应该总是用 SqlSessionTemplate 来替换 MyBatis 默认的 DefaultSqlSession 实现。在同一应用程序中的不同类之间混杂使用可能会引起数据一致性的问题。
整合实现一
- 引入Spring配置文件spring-dao.xml
- 配置数据源替换MyBatis的数据源
- 配置SqlSessionFactoryBean,同时关联MyBatis
- 注册SqlSessionTemplate,关联SqlSessionFactory
- 增强Dao接口实现类,私有化sqlSessionTemplate
- 注册bean实现
- 测试
spring-dao.xml
<?xml version="1.0" encoding="UTF8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--
DataSource:使用Spring的数据源替换MyBatis的配置 c3p0 dbcp druid
我们这里使用spring提供的JDBC:org.springframework.jdbc.datasource
-->
<bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url"
value="jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&useSSL=true&characterEncoding=utf-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</bean>
<!--sqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="datasource"/>
<!--绑定MyBatis配置文件-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:com/jian/mapper/*.xml"/>
</bean>
<!--sqlSessionTemplate就相当于我们在MyBatis中使用的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--因为它没有set方法,所以只能用构造器注入-->
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
</beans>
mybatis-config.xml
<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--别名也可以在spring-dao.xml中的sqlSessionFactory配置-->
<typeAliases>
<package name="com.jian.pojo"/>
</typeAliases>
<!--
这个已经在spring-dao.xml中的sqlSessionFactory配置了
<mappers>
<package name="com.jian.mapper"/>
</mappers>
-->
</configuration>
applicationContext.xml
<?xml version="1.0" encoding="UTF8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<import resource="spring-dao.xml"/>
<bean id="userMapper" class="com.jian.mapper.UserMapperImpl">
<property name="sqlSession" ref="sqlSession"/>
</bean>
</beans>
UserServiceImpl.java
package com.jian.mapper;
import com.jian.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;
import java.util.List;
public class UserMapperImpl implements UserMapper {
//我们所有操作原来都使用sqlSession来执行,现在使用sqlSessionTemplate,二者等价
private SqlSessionTemplate sqlSession;
public void setSqlSession(SqlSessionTemplate sqlSession) {
this.sqlSession = sqlSession;
}
@Override
public List<User> getUsers() {
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
return mapper.getUsers();
}
}
测试类
import com.jian.mapper.UserMapper;
import com.jian.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
@Test
public void test() {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper userMapper = (UserMapper) context.getBean("userMapper");
for (User user : userMapper.getUsers()) {
System.out.println(user);
}
}
}
整合实现二
UserMapperImpl实现类继承SqlSessionDaoSupport类,实现UserService方法,SqlSessionDaoSupport类中可以直接获取到SqlSessionTemplate(SqlSession),不需要在spring-dao.xml中注入SqlSessionTemplate对象了
实现一的基础上applicationContext.xml中添加以下
<bean id="userMapperT" class="com.jian.mapper.UserServiceImplT">
<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>
接口实现类UserServiceImplT
package com.jian.mapper;
import com.jian.pojo.User;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.List;
public class UserServiceImplT extends SqlSessionDaoSupport implements UserMapper {
@Override
public List<User> getUsers() {
UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
return mapper.getUsers();
}
}
实体类,接口,mapper.xml是跟实现一一样的
spring-dao.xml中可以省略以下,其余和实现一中的spring-dao.xml配置一样
<!--sqlSessionTemplate就相当于我们在MyBatis中使用的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--因为它没有set方法,所以只能用构造器注入-->
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
13. 声明式事务
13.1 回顾事务
- 把一组业务当成一个业务来做,要么都成功,要么都失败
- 事务在项目开发过程非常重要,涉及到数据的一致性的问题,不容马虎!
- 事务管理是企业级应用程序开发中必备技术,用来确保数据的完整性和一致性
事务就是把一系列的动作当成一个独立的工作单元,这些动作要么全部完成,要么全部不起作用
事务四个特性ACID
-
原子性(atomicity)
-
- 事务是原子性操作,由一系列动作组成,事务的原子性确保动作要么全部完成,要么完全不起作用
-
一致性(consistency)
-
- 一旦所有事务动作完成,事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中
-
隔离性(isolation)
-
- 可能多个事务会同时处理相同的数据,因此每个事务都应该与其他事务隔离开来,防止数据损坏
-
持久性(durability)
-
- 事务一旦完成,无论系统发生什么错误,结果都不会受到影响。通常情况下,事务的结果被写到持久化存储器中
13.2 测试
实体类/mybatis-config.xml/spring-dao.xml/applicationContext.xml与上面整合实现二一致,在UserMapper接口、UserMapper.xml、UserMapperImpl
中新增addUser()/deleteUser()方法
UserMapper.xml
<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jian.mapper.UserMapper">
<select id="getUsers" resultType="user">
select *
from users
</select>
<insert id="addUser" parameterType="user">
insert into users
values (#{id}, #{name}, #{password}, #{email}, #{birthday})
</insert>
<delete id="deleteUser">
deletes <!--特意写deletes-->
from users
where id = #{uid}
</delete>
</mapper>
UserMapperImpl
package com.jian.mapper;
import com.jian.pojo.User;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.Date;
import java.util.List;
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
@Override
public List<User> getUsers() {
User user=new User(6,"Anna","123456",new Date(),"666@163.com");
int i = addUser(user);
int i1 = deleteUser(6);
UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
return mapper.getUsers();
}
@Override
public int addUser(User user) {
UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
return mapper.addUser(user);
}
@Override
public int deleteUser(int id) {
UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
return mapper.deleteUser(id);
}
}
结果:用户新增成功,但是删除失败
没有进行事务的管理;我们想让他们都成功才成功,有一个失败,就都失败,我们就应该需要事务!
13.3 Spring中的事务管理
Spring在不同的事务管理API之上定义了一个抽象层,使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式事务管理
编程式事务管理
- 将事务管理代码嵌到业务方法中来控制事务的提交和回滚
- 缺点:必须在每个事务操作业务逻辑中包含额外的事务管理代码
声明式事务
- 一般情况下比编程式事务好用
- 将事务管理代码从业务方法中分离出来,以声明的方式来实现事务管理
- 将事务管理作为横切关注点,通过AOP方法模块化,Spring中通过SpringAOP框架支持声明式事务
使用Spring管理事务,注意头文件的约束导入:tx
xmlns:tx="http://www.springframework.org/schema/tx"
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
事务管理器
- 无论使用Spring的哪种事务管理策略(编程式或者声明式)事务管理器都是必须的。
- 就是 Spring的核心事务管理抽象,管理封装了一组独立于技术的方法。
JDBC事务
<!--配置声明式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="datasource"/>
</bean>
配置好事务管理器后我们需要去配置事务的通知
<!--结合AOP实现事务织入-->
<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="add" propagation="REQUIRED"/>
<tx:method name="delete" propagation="REQUIRED"/>
<tx:method name="update" propagation="REQUIRED"/>
<tx:method name="query" read-only="true"/>
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
spring事务传播特性:
事务传播行为就是多个事务方法相互调用时,事务如何在这些方法间传播。spring支持7种事务传播行为:
- propagation_requierd:如果当前没有事务,就新建一个事务,如果已存在一个事务中,加入到这个事务中,这是最常见的选择。
- propagation_supports:支持当前事务,如果没有当前事务,就以非事务方法执行。
- propagation_mandatory:使用当前事务,如果没有当前事务,就抛出异常。
- propagation_required_new:新建事务,如果当前存在事务,把当前事务挂起。
- propagation_not_supported:以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。
- propagation_never:以非事务方式执行操作,如果当前事务存在则抛出异常。
- propagation_nested:如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则执行与propagation_required类似的操作
Spring 默认的事务传播行为是 PROPAGATION_REQUIRED,它适合于绝大多数的情况
配置AOP
导入AOP头文件
xmlns:tx="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--配置事务切入-->
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* com.jian.mapper.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>
</aop:config>
完整的spring-dao.xml
<?xml version="1.0" encoding="UTF8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url"
value="jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&useSSL=true&characterEncoding=utf-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="datasource"/>
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:com/jian/mapper/*.xml"/>
</bean>
<!--配置声明式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="datasource"/>
</bean>
<!--结合AOP实现事务织入-->
<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="add" propagation="REQUIRED"/>
<tx:method name="delete" propagation="REQUIRED"/>
<tx:method name="update" propagation="REQUIRED"/>
<tx:method name="query" read-only="true"/>
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!--配置事务切入-->
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* com.jian.mapper.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>
</aop:config>
</beans>
为什么要配置事务?
- 如果不配置,就需要我们手动提交控制事务
- 事务在项目开发过程非常重要,涉及到数据的一致性问题,不容马虎!