一.Spring
1.简介
- 2002年首次推出Spring框架的雏形：interface21框架
- Spring理念：使现在的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架
官方下载地址：repo.spring.io
中文文档：Spring Framework 中文文档 - Spring Framework 5.1.3.RELEASE Reference | Docs4dev
GitHub:GitHub - spring-projects/spring-framework: Spring Framework
导入jar包
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.19</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.19</version>
</dependency>
2.优点
- Spring是一个开源的免费的框架
- Spring是一个轻量级，非入侵式的框架
- 控制反转(IOC)，面向切面编程(AOP)
- 支持事务的处理，对框架整合的支持
总结：Spring就是一个轻量级的控制反转和面向切面编程的框架
3.组成
4.拓展
Spring官网介绍：现代化的Java开发就是基于Spring的开发
Spring Boot
- 一个快速开发的脚手架
- 基于SpringBoot可以快速的开发单个微服务
- 约定大于配置
Spring Cloud
- SpringCloud是基于SpringBoot实现的
学习SpringBoot的前提需要完全掌握Spring及SpringMVC
弊端：发展太久了违背了当初的理念，配置十分繁琐
二.IOC理论推导
1.UserDao接口
package com.jiu.dao;
public interface UserDao {
void getUser();
}
2.UserDaoImpl实现类
package com.jiu.dao;
public class UserDaoImpl implements UserDao{
@Override
public void getUser() {
System.out.println("默认获取用户的数据");
}
}
package com.jiu.dao;
public class UserDaoMysqlImpl implements UserDao{
private UserDao userDao;
public void getUser() {
System.out.println("数据");
}
}
3.UserService业务接口
package com.jiu.service;
public interface UserService {
void getUser();
}
4.UserServiceImpl业务实现类
在之前的业务中。用户的需求可能影响我们原来的代码，我们需要根据用的需求去修改代码，如果代码量巨大修改成本十分昂贵，然而我们的Set接口可以使之发生改变
package com.jiu.service;
import com.jiu.dao.UserDao;
import com.jiu.dao.UserDaoImpl;
public class UserServiceImpl implements UserService{
private UserDao userDao;
//利用set进行动态实现值的注入
public void setUserDao(UserDao userDao){
this.userDao = userDao;
}
public void getUser() {
userDao.getUser();
}
}
- 之前程序是主动创建对象控制权在程序员手上
- 使用set注入后，程序不再具有主动性，而是变成了被动的接收对象
这种思想从本质上解决了问题，系统的耦合性大大降低，可以更加专注在业务的实现上，这是IOC的原型
5.测试类
import com.jiu.dao.UserDaoImpl;
import com.jiu.dao.UserDaoMysqlImpl;
import com.jiu.service.UserService;
import com.jiu.service.UserServiceImpl;
public class MyTest {
public static void main(String[] args) {
//用户实际调用的是业务层，dao层他们不需要接触
UserService userService = new UserServiceImpl();
((UserServiceImpl) userService).setUserDao(new UserDaoMysqlImpl());
userService.getUser();
}
}
IOC本质
控制反转loC(Inversion of Control),是-种设计思想，DI(依赖注入)是实现IoC的一 -种方法，也有人认为DI只是loC的另一种说法。 没有IoC的程序中,我们使用面向对象编程,对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是:获得依赖对象的方式反转了。
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入(Dependency Injection,DI)。
三.HelloSpring
实体类
package com.jiu.pojo;
public class Hello {
private String str;
public Hello() {
}
public Hello(String str) {
this.str = str;
}
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
@Override
public String toString() {
return "Hello{" +
"str='" + str + '\'' +
'}';
}
}
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">
<!--使用Spring来创建对象，在Spring这里都称为Bean
类型 变量名 = new 类型();
Hello hello = new Hello();
id = 变量名
class = new的对象
property相当于给对象的属性设置一个值
-->
<bean id="hello" class="com.jiu.pojo.Hello">
<property name="str" value="Spring"/>
</bean>
</beans>
测试类
import com.jiu.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
//获取Spring上下文对象
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//我们的对象现在都在Spring中管理了，我们要使用直接取出来就好了
Hello hello = (Hello)context.getBean("hello");
System.out.println(hello.toString());
}
}
思考问题？
Hello对象是谁创建的？
- Hello对象是由Spring创建的
Hello对象的属性是怎么设置的？
- Hello对象的属性是由Spring容器设置的
这个过程就叫控制反转：
控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的。
反转：程序本身不创建对象，而变成被动的接收对象。
依赖注入：就是利用set方法来进行注入的。
IOC是一种编程思想，由主动的编程变成被动的接收。
可以通过new ClassPathXmlApplicationContext去浏览一下底层源码。
到了现在，我们彻底不用在程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓的IOC，一句话搞定：对象由Spring来创建，管理，装配！
四.创建对象的方式
我们默认使用无参构造创建对象，如果我们要使用有参构造创建对象有以下三种方式
1.下标赋值
<!--下标赋值-->
<bean id="user" class="com.jiu.pojo.User">
<constructor-arg index="0" value="九七学Java"/>
</bean>2.类型(不建议使用)
<!--通过类型创建
但如果两个类型相同就无法使用所以不建议使用此方法
-->
<bean id="user" class="com.jiu.pojo.User">
<constructor-arg type="java.lang.String" value="杨博文"/>
</bean>3.参数名赋值
<!--通过参数名赋值-->
<bean id="user" class="com.jiu.pojo.User">
<constructor-arg name="name" value="杨涵博"/>
</bean>总结：在配置文件加载的时候，容器中管理的对象就已经初始化了！
五.Spring配置
1.别名
<!--起别名-->
<alias name="user" alias="ly"/>2.Bean的配置
<!--
id:bean的唯一标识符，也就相当于对象名
class：bean对象所对应的全限定名
name：也是别名,比alias更高级，可以起多个别名,空格、逗号、分号都可以起别名
-->
<bean id="userT" class="com.jiu.pojo.UserT" name="user2,u2 u3;u4">
<property name="name" value="11"/>
</bean>3.import
这个import一般用于团队开发使用，它可以将多个配置文件合并成一个
团队每个人独自编写xml，最后我们用<import resource="不同成员编写的xml文件名"/>合并到主xml上
六.依赖注入
1.构造器注入
- 前面就是
2.set方式注入(重点)
依赖注入：set注入
- 依赖：bean对象的创建依赖于容器
- 注入：bean对象中的所有属性由容器来注入
【环境搭建】
1.复杂类型
package com.jiu.pojo;
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Address{" +
"address='" + address + '\'' +
'}';
}
}
2.真实测试
package com.jiu.pojo;
import java.util.*;
public class Student {
private String name;
private Address address;
private String[] books;
private List<String> hobbys;
private Map<String,String> map;
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> getHobbys() {
return hobbys;
}
public void setHobbys(List<String> hobbys) {
this.hobbys = hobbys;
}
public Map<String, String> getMap() {
return map;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
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) +
", hobbys=" + hobbys +
", map=" + map +
", games=" + games +
", wife='" + wife + '\'' +
", info=" + info +
'}';
}
}
3.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="student" class="com.jiu.pojo.Student">
<property name="name" value="九七"/>
</bean>
</beans>
4.测试
import com.jiu.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student student = (Student)context.getBean("student");
System.out.println( student.getName());
}
}
5.完善注入
<?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.jiu.pojo.Address">
<property name="address" value="南昌"/>
</bean>
<bean id="student" class="com.jiu.pojo.Student">
<!--第一种 普通注入 value-->
<property name="name" value="九七"/>
<!--第二种 bean注入 ref-->
<property name="address" ref="address"/>
<!--第三种 数组注入-->
<property name="books">
<array>
<value>红楼梦</value>
<value>西游记</value>
<value>三国演义</value>
<value>水浒传</value>
</array>
</property>
<!--第四种 List-->
<property name="hobbys">
<list>
<value>听歌</value>
<value>打游戏</value>
<value>看电影</value>
</list>
</property>
<!--第五种 Map-->
<property name="map">
<map>
<entry key="身份证" value="12421432151352"/>
<entry key="手机号" value="13712312411"/>
</map>
</property>
<!--第六种 Set-->
<property name="games">
<set>
<value>永劫无间</value>
<value>王者荣耀</value>
</set>
</property>
<!--第七种 null-->
<property name="wife">
<null/>
</property>
<!--第八种 Properties-->
<property name="info">
<props>
<prop key="学号">20200907</prop>
<prop key="username">可乐</prop>
<prop key="password">21412</prop>
</props>
</property>
</bean>
</beans>
3.拓展方式注入 (了解)
我们可以使用p命名空间和c命名空间进行注入
实体类
package com.jiu.pojo;
public class User {
private String name;
private int age;
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
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"
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命名空间注入，可以直接注入属性的值-->
<bean id="user" class="com.jiu.pojo.User" p:name="嘟嘟" p:age="13"/>
<!--c命名空间注入，通过构造器注入：construct-args-->
<bean id="user2" class="com.jiu.pojo.User" c:name="吱吱" c:age="18"/>
</beans>
测试
import com.jiu.pojo.Student;
import com.jiu.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student student = (Student)context.getBean("student");
System.out.println( student.toString());
}
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("user.xml");
//显示声明类型后就不用强转了
User user = context.getBean("user2",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"
4.bean的作用域
1.单例模式(Spring默认模式)
<bean id="user2" class="com.jiu.pojo.User" c:name="吱吱" c:age="18" scope="singleton"/>2.原型模式，每次从容器中get的时候都会产生一个新的对象
<bean id="user2" class="com.jiu.pojo.User" c:name="吱吱" c:age="18" scope="prototype"/>3.其余的request、session、application、这些只能在web开发中使用到！
七.Bean的自动装配
- 自动装配是Spring满足bean依赖的一种方式
- Spring会在上下文中自动寻，并自动给bean装配属性
在Spring中有三种装配的方式
- 在xml中显示的装配
- 在Java中显示的配
- 隐式的自动装配bean【重点】
1.测试
搭建环境 一个人和两个宠物
<bean id="cat" class="com.jiu.pojo.Cat"/>
<bean id="dog" class="com.jiu.pojo.Dog"/>
<bean id="people" class="com.jiu.pojo.People">
<property name="cat" ref="cat"/>
<property name="dog" ref="dog"/>
<property name="name" value="九七"/>
</bean>2.ByName自动装配
<bean id="cat" class="com.jiu.pojo.Cat"/>
<bean id="dog" class="com.jiu.pojo.Dog"/>
<!--byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的bean id-->
<bean id="people" class="com.jiu.pojo.People" autowire="byName">
<property name="name" value="九七"/>
</bean>3. ByType自动装配
<bean class="com.jiu.pojo.Cat"/>
<bean class="com.jiu.pojo.Dog"/>
<!--
byType：会自动在容器上下文中查找，和自己对象属性类型相同的bean！
即使id写错甚至不写都没有问题
-->
<bean id="people" class="com.jiu.pojo.People" autowire="byType">
<property name="name" value="九七"/>
</bean>
小结：
- ByName的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致！
- ByType的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致！
4.使用注解实现自动装配
jdk1.5支持的注解，Spring2.5支持的注解了
要使用注解须知：
1.导入约束：context
2.配置注解的支持：<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(Spring)容器中存在，且符合名字ByName！
科普：@Nullable 字段标记了这个注解，说明这个字段可以为null;
可以为null的原因：
public @interface Autowired {
boolean required() default true;
}
测试：
public class People {
//如果显式定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空
@Autowired(required = false)
private Cat cat;
@Autowired
private Dog dog;
private String name;
}
如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以使用@Qualifier(value = “xxx”)去配置@Autowired的使用，指定一个唯一的bean对象注入！(即使装配文件再多如果有正确的那个不用这么写也能执行)
实体类：
@Autowired
private Cat cat;
@Autowired
@Qualifier(value = "dog111")
private Dog dog;
private String name;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="cat" class="com.jiu.pojo.Cat"/>
<!-- <bean id="dog" class="com.jiu.pojo.Dog"/>-->
<bean id="dog111" class="com.jiu.pojo.Dog"/>
<bean id="dog222" class="com.jiu.pojo.Dog"/>
<bean id="people" class="com.jiu.pojo.People"/>
</beans>
@Resource
@Resource(name = "cat222")
private Cat cat;@Resource和@Autowired的区别：
- 都是用来自动装配的，都可以放在属性字段上
- @Autowired通过byType的方式实现，而且必须要求这个对象存在！【常用】
- @Resource默认通过byName的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！【常用】
八.使用注解开发
在Spring之后使用注解开发必须要保证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:annotation-config/>
</beans>
1.bean
2.属性如何注入
package com.jiu.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
//等价于 <bean id="user" class="com.jiu.pojo.User"/>
@Component
public class User {
@Value("九七")
//等价于<property name="name" value="九七"/>
public String name;
}
3.衍生的注解
@Component有几个衍生注解，我们在web开发中会按照mvc三层架构分层，在不同层用不同的注解但功能相同都是代表将某个类注册到Spring中，装配Bean
- dao 【@Repository】
- service 【@Service】
- controller 【@Controller】
4.自动装配
- @Autowired：自动装配通过类型，名字。如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value = "xxx")去配置。
- @Nullable 字段标记了了这个注解，说明这个字段可以为null;
- @Resource：自动装配通过名字，类型。
5.作用域
@Scope("singleton")
6.小结
xml与注解
- xml更加万能适用于任何场合，维护简单方便
- 注解不是自己的类是用不了，维护相对复杂
xml与注解最佳实践
- xml用来管理bean；
- 注解只负责完成属性的注入；
- 我们在使用的过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持
!--指定扫描的包，这个包的注解机会生效-->
<context:component-scan base-package="com.jiu"/>
<context:annotation-config/>九.使用Java的方式配置Spring
我们现在要完全不使用Spring的xml配置了，全权交给Java来做！
JavaConfig是Spring的一个子项目，在Spring4之后，它成为了一个核心功能！
实体类
package com.jiu.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
@Controller
public class User {
public String name;
public String getName() {
return name;
}
@Value("昊天")
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
配置类
package com.jiu.config;
import com.jiu.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;
//这个也会被Spring容器托管，注册到容器中，因为他本来就是@Component
//@Configuration代表这是一个配置类，就是我们之前的beans.xml
@Configuration
@ComponentScan("com.jiu.pojo")
@Import(JiuConfig2.class)
public class JiuConfig {
//相当于之前的bean标签，方法名字相当于标签的id，返回值相当于标签的class属性
@Bean
public User user(){
return new User();
}
}
测试
import com.jiu.config.JiuConfig;
import com.jiu.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext(JiuConfig.class);
User user = (User)context.getBean("user");
System.out.println(user.getName());
}
}
十.代理模式
为什么要学习代理模式？
- 因为这就是SpringAOP的底层！
SpringAOP和SpringMVC是面试高频
代理模式分为：动态代理和静态代理
1.静态代理
角色分析：
- 抽象角色：一般会使用接口或者抽象类来解决
- 真实角色：被代理的角色
- 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
- 客户：访问代理对象的人！
步骤：
1.接口
package com.jiu.demo01;
public interface Rent {
public void rent();
}
2.真实角色
package com.jiu.demo01;
public class Host implements Rent{
@Override
public void rent() {
System.out.println("房东要出租房子");
}
}
3.代理角色
package com.jiu.demo01;
public class Proxy {
private Host host;
public Proxy() {
}
public Proxy(Host host) {
this.host = host;
}
public void rent() {
host.rent();
seeHouse();
hetong();
fare();
}
public void seeHouse(){
System.out.println("看房");
}
public void hetong(){
System.out.println("签租赁合同");
}
public void fare(){
System.out.println("中介费");
}
}
4.客户
package com.jiu.demo01;
public class Client {
public static void main(String[] args) {
//房东要租出房子
Host host = new Host();
//代理，中介代理房东出租房子，但是会有附属操作
Proxy proxy = new Proxy(host);
//不见房东找中介租房
proxy.rent();
}
}
代理模式的好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共角色就交给代理角色！实现了业务的分工！
- 公共业务发生扩展的时候，方便集中管理！
缺点：
- 一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低
2.加深理解
1.接口
package com.jiu.Demo02;
public interface UserService {
public void add();
public void delete();
public void update();
public void query();
}2.原有代码
package com.jiu.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("查询一个用户");
}
}
3.创建一个新的类在原有代码加新的方法（改变原有代码是公司大忌）
package com.jiu.Demo02;
public class UserServiceProxy implements UserService{
private UserServiceImpl userService;
public void setUserService(UserServiceImpl userService) {
this.userService = userService;
}
@Override
public void add() {
log("add");
userService.add();
}
@Override
public void delete() {
log("delete");
userService.delete();
}
@Override
public void update() {
userService.update();
}
@Override
public void query() {
userService.query();
}
//日志方法
public void log(String msg) {
System.out.println("使用了"+msg+"方法");
}
}
4.测试
package com.jiu.Demo02;
public class Client {
public static void main(String[] args) {
UserServiceImpl userService = new UserServiceImpl();
UserServiceProxy userServiceProxy = new UserServiceProxy();
userServiceProxy.setUserService(userService);
userServiceProxy.delete();
}
}
3.动态代理
1.动态代理和静态代理角色一样
2.动态代理的代理类是动态生成的，不是我们直接写好的！
3.动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口 — JDK动态代理【我们在这里使用】
- 基于类：cglib
- java字节码实现：javassist
需要了解两个类：Proxy：代理；InvocationHandler：调用处理程序。
动态代理的好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共角色就交给代理角色！实现了业务的分工！
- 公共业务发生扩展的时候，方便集中管理！
- 一个动态代理类代理的是一个接口，一般就是对应的一类业务
- 一个动态代理类可以代理多个类，只要是实现了同一个接口即可！
步骤 ：
1.接口
package com.jiu.demo03;
public interface Rent {
public void rent();
}
2.真实角色
package com.jiu.demo03;
public class Host implements Rent {
@Override
public void rent() {
System.out.println("房东要出租房子");
}
}
3.动态代理类
package com.jiu.demo03;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//我们会用这个类自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
//被代理的接口
private Rent rent;
public void setRent(Rent rent) {
this.rent = rent;
}
//生成得到代理类
public Object getProxy() {
return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(),this);
}
@Override
//处理代理实例，并返回结果
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
seeHouse();
//动态代理的本质就是使用反射机制
Object result = method.invoke(rent, args);
fare();
return result;
}
public void seeHouse(){
System.out.println("中介带看房子");
}
public void fare(){
System.out.println("收中介费");
}
}
4.测试
package com.jiu.demo03;
public class Client {
public static void main(String[] args) {
//真实角色
Host host = new Host();
//代理角色 不存在
ProxyInvocationHandler pih = new ProxyInvocationHandler();
//通过调用程序处理角色来处理我们要调用的接口对象
pih.setRent(host);
Rent proxy = (Rent)pih.getProxy();//这里的proxy就是动态生成的，我们没有写
proxy.rent();
}
}
十一.AOP
1.什么是aop？
AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
2.AOP在Spring中的作用(不用特别理解)
横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等…
切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
目标（Target）：被通知对象。
代理（Proxy）：向目标对象应用通知之后创建的对象。
切入点（PointCut）：切面通知执行的“地点”的定义。
连接点（JointPoint）：与切入点匹配的执行点。
SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice：
即AOP在不改变原有代码的情况下，去增加新的功能。
3.使用Spring实现AOP
使用AOP，需要导入一个依赖包！
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
方式一： 使用Spring的API接口【主要是SpringAPI接口实现】
1.接口
package com.jiu.service;
public interface UserService {
public void add();
public void delete();
public void update();
public void query();
}
2.实现类
package com.jiu.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 query() {
System.out.println("查询了一个用户");
}
}
3.使用AOP定义的增强类
package com.jiu.log;
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
public class Log implements MethodBeforeAdvice {
@Override
/*
method:要执行的目标对象方法
args：参数
target：目标对象
*/
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
}
}
package com.jiu.log;
import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
public class AfterLog implements AfterReturningAdvice {
@Override
//returnValue:返回值
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println("执行了"+method.getName()+"方法，返回结果为:"+returnValue);
}
}
4.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
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.jiu.service.UserServiceImpl"/>
<bean id="log" class="com.jiu.log.Log"/>
<bean id="afterLog" class="com.jiu.log.AfterLog"/>
<!--方式一：使用原生的·Spring API接口-->
<!--配置AOP:需要导入aop的约束-->
<aop:config>
<!--切入点：expression 表达式：execution(要执行的位置！* * * * *)-->
<aop:pointcut id="pointcut" expression="execution(* com.jiu.service.UserServiceImpl.*(..))"/>
<!--执行环绕增加-->
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>
</beans>
5.测试
import com.jiu.service.UserService;
import com.jiu.service.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//动态代理的是接口，不要要写成实现类
UserService userService = (UserService) context.getBean("userService");
userService.add();
}
}
方式二： 自定义类来实现AOP【主要是切面定义】
1.自己编写的切入类
package com.jiu.diy;
public class DiyPoinCut {
public void before() {
System.out.println("============方法执行前==========");
}
public void after() {
System.out.println("============方法执后==========");
}
}
2.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
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.jiu.service.UserServiceImpl"/>
<bean id="log" class="com.jiu.log.Log"/>
<bean id="afterLog" class="com.jiu.log.AfterLog"/>
<!--自定义类-->
<bean id="diy" class="com.jiu.diy.DiyPoinCut"/>
<aop:config>
<aop:aspect ref="diy">
<!--切入点-->
<aop:pointcut id="pointcut" expression="execution(* com.jiu.service.UserServiceImpl.*(..))"/>
<!--通知-->
<aop:before method="before" pointcut-ref="pointcut"/>
<aop:after method="after" pointcut-ref="pointcut"/>
</aop:aspect>
</aop:config>
</beans>
方式三： 使用注解实现
1.注解实现增强类
package com.jiu.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;
//方式三：使用注解类实现AOP
@Aspect//标注这个类为切面
public class AnnotationPointCut {
@Before("execution(* com.jiu.service.UserServiceImpl.*(..))")
public void before() {
System.out.println("============方法执行前==========");
}
@After("execution(* com.jiu.service.UserServiceImpl.*(..))")
public void after() {
System.out.println("============方法执后==========");
}
//在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
@Around("execution(* com.jiu.service.UserServiceImpl.*(..))")
public void around(ProceedingJoinPoint jp) throws Throwable {
System.out.println("环绕前");
Signature signature = jp.getSignature();//获得签名
System.out.println("signature"+signature);
//执行方法
Object proceed = jp.proceed();
System.out.println("环绕后");
}
}
2.xml
<!--方式三-->
<bean id="cut" class="com.jiu.diy.AnnotationPointCut"/>
<!--开启注解支持-->
<aop:aspectj-autoproxy/>十二.整合Mybatis
1.回忆Mybatis
1.导入相关jar包
- junit
- mybatis
- mysql数据库
- spring相关
- aop织入器
- mybatis-spring整合包【重点】在此还导入了lombok包。
- 配置Maven静态资源过滤问题！
<?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-study</artifactId>
<groupId>org.example</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>spring-10-mybatis</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.2</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.19</version>
</dependency>
<!--spring操作数据库还需要一个spring-jdbc-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.19</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.2</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.10</version>
</dependency>
</dependencies>
<!--在build中配置resources，来防止我们资源导出失败的问题-->
<build>
<resources>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
</build>
</project>2.编写实体类
package com.jiu.pojo;
import lombok.Data;
@Data
public class User {
private int id;
private String name;
private String pwd;
}
3.核心配置文件
<?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核心配置文件-->
<configuration>
<typeAliases>
<package name="com.jiu.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/mybatis?useSSL=false&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="201408181"/>
</dataSource>
</environment>
</environments>
<!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册-->
<mappers>
<mapper resource="com/jiu/mapper/UserMapper.xml"/>
</mappers>
</configuration>4.测试
import com.jiu.mapper.UserMapper;
import com.jiu.pojo.User;
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 org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class MyTest {
@Test
public void selectUser() throws IOException {
String resources = "mybatis-config.xml";
InputStream in = Resources.getResourceAsStream(resources);
SqlSessionFactory build = new SqlSessionFactoryBuilder().build(in);
SqlSession sqlSession = build.openSession(true);
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> users = mapper.selectUser();
for (User user : users) {
System.out.println(user);
}
}
}
2.Mybatis-Spring
MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中
文档链接：mybatis-spring –
整合方式一：
1.实体类
package com.jiu.pojo;
import lombok.Data;
@Data
public class User {
private int id;
private String name;
private String pwd;
}
2.Usermapper接口
package com.jiu.mapper;
import com.jiu.pojo.User;
import java.util.List;
public interface UserMapper {
public List<User> selectUser();
}
3.UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jiu.mapper.UserMapper">
<!--select查询语句-->
<select id="selectUser" resultType="user">
select * from mybatis.user
</select>
</mapper>4.Spring配置文件
<?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">
</beans>
5.配置数据源替换mybaits的数据源
<?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">
<!--DataSource:使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid-->
<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/mybatis?useSSL=false&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="201408181"/>
</bean>
</beans>
7.更改Mybatis配置文件（一般只保留setting和configuration）
<?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核心配置文件-->
<configuration>
<typeAliases>
<package name="com.jiu.pojo"/>
</typeAliases>
</configuration>8.配置SqlSessionFactory，关联MyBatis
<?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">
<!--DataSource:使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid-->
<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/mybatis?useSSL=false&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="201408181"/>
</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/jiu/mapper/*.xml"/>
</bean>
</beans>
9.注册sqlSessionTemplate，关联sqlSessionFactory
<?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">
<!--DataSource:使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid-->
<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/mybatis?useSSL=false&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="201408181"/>
</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/jiu/mapper/*.xml"/>
</bean>
<!--SqlSessionTemplate:就是我们使用的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--只能使用构造器注入sqlSessionFactory，因为它没有set方法-->
<constructor-arg index="0" ref="sqlSessionFactory" />
</bean>
</beans>
10.UserMapperImpl 实现类
package com.jiu.mapper;
import com.jiu.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> selectUser() {
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
return mapper.selectUser();
}
}
11.将自己写的实现类，注入到Spring配置文件中
<?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">
<!--DataSource:使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid-->
<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/mybatis?useSSL=false&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="201408181"/>
</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/jiu/mapper/*.xml"/>
</bean>
<!--SqlSessionTemplate:就是我们使用的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--只能使用构造器注入sqlSessionFactory，因为它没有set方法-->
<constructor-arg index="0" ref="sqlSessionFactory" />
</bean>
<bean id="userMapper" class="com.jiu.mapper.UserMapperImpl">
<property name="sqlSession" ref="sqlSession"/>
</bean>
</beans>
12.测试
import com.jiu.mapper.UserMapper;
import com.jiu.pojo.User;
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 org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class MyTest {
@Test
public void selectUser() throws IOException {
ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
for (User user : userMapper.selectUser()) {
System.out.println(user);
}
}
}
整合方式二：
1.在方式一的基础上修改UserMapperImpl实现类
package com.jiu.mapper;
import com.jiu.pojo.User;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.List;
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{
@Override
public List<User> selectUser() {
return getSqlSession().getMapper(UserMapper.class).selectUser();
}
}
2.在xml文件配置重新配置自己的类，xml文件上的相当于以前的sqlSession注入也可以删除
<?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">
<!--DataSource:使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid-->
<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/mybatis?useSSL=false&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="201408181"/>
</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/jiu/mapper/*.xml"/>
</bean>
<bean id="userMapper2" class="com.jiu.mapper.UserMapperImpl2">
<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>
</beans>
3.测试
import com.jiu.mapper.UserMapper;
import com.jiu.pojo.User;
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 org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class MyTest {
@Test
public void selectUser() throws IOException {
ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
UserMapper userMapper = context.getBean("userMapper2", UserMapper.class);
for (User user : userMapper.selectUser()) {
System.out.println(user);
}
}
}
十三.声明式事务
1.回顾事务
- 把一组业务当成一个业务来做；要么都成功，要么都失败！
- 事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎！
- 确保完整性和一致性。
事务ACID原则:
1.原子性（atomicity）
- 事务的原子性确保动作要么全部完成，要么完全不起作用。
2.一致性（consistency）
- 一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中。
3.隔离性（isolation）
- 多个事务可能操作同一个资源，防止数据破坏
4.持久性（durability）
- 事务一旦提交，无论系统发生什么错误，结果都不会受到影响，被持久化的写到存储器中
2.Spring中的事务管理
声明式事务:AOP
编程式事务 :需要在代码中进行事务的管理
思考：
为什么需要事务？
- 如果不配置事务，可能存在数据提交不一致的情况；
- 如果我们不在Spring中去配置声明式事务，我们就需要在代码中手动配置事务！
- 事务在项目的开发中十分重要，涉及到数据的一致性和完整性问题，不容马虎！
代码：
1.把十二的代码复制过来
2.在UserMapper接口加入新的方法
public int addUser(User user);
public int deleteUser(@Param("id") int id);3.在UserMapper.xml完成方法，但故意把delete写成deletes
<insert id="addUser" >
insert into mybatis.user (id, name, pwd) values (#{id}, #{name}, #{pwd});
</insert>
<delete id="deleteUser">
deletes from mybatis.user where id = #{id}
</delete>3.在UserMapperImpl中加入我们新写的方法
package com.jiu.mapper;
import com.jiu.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.List;
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper{
@Override
public List<User> selectUser() {
User user = new User(7, "赵九", "123123111");
UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
mapper.addUser(user);
mapper.deleteUser(6);
return getSqlSession().getMapper(UserMapper.class).selectUser();
}
@Override
public int addUser(User user) {
return getSqlSession().getMapper(UserMapper.class).addUser(user);
}
@Override
public int deleteUser(int id) {
return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
}
}
4.测试
import com.jiu.mapper.UserMapper;
import com.jiu.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
userMapper.selectUser();
for (User user : userMapper.selectUser()) {
System.out.println(user);
}
}
}
这时我们查看数据库发现我们添加的数据被成功添加，而我们删除的数据因为我们故意写错而不能删除，而我们如果想让他们同时失败就需要下面的事务操作
5.在xml配置声明式事务
<!--配置声明式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>6.在xml结合AOP实现事物的织入配置事务通知
<!--结合AOP实现事物的织入-->
<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!--给那些方法配置事务-->
<!--配置事务的传播特性：new propagation=-->
<tx:attributes>
<tx:method name="add" propagation="REQUIRED"/>
<tx:method name="delete"/>
<tx:method name="update"/>
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>7.xml配置事务切入
<aop:config> <aop:pointcut id="txPointCut" expression="execution(* com.jiu.mapper.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>
8.测试
import com.jiu.mapper.UserMapper;
import com.jiu.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
userMapper.selectUser();
for (User user : userMapper.selectUser()) {
System.out.println(user);
}
}
}
发现删除和添加都不能在数据库生效，说明我们的事务生效了
56万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
