Spring5

南绘

已于 2022-07-17 10:38:37 修改

阅读量100

点赞数

分类专栏： Spring5 文章标签： spring java mybatis

于 2022-07-16 16:12:58 首次发布

本文链接：https://blog.csdn.net/weixin_53089304/article/details/125821147

版权

Spring5 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1，Spring

1.1 简介

2002年首次推出了Spring框架雏形：interface21框架
Spring框架以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日，发布了1.0正式版
Rod Johnson，Spring Framework创始人，注明作者
Spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架
早年SSH：Struct2+Spring+Hibernate
现在SSM：SpringMVC+Spring+Mybatis

官网：https://spring.io/projects/spring-framework#overview
官方下载地址：https://repo.spring.io/ui/native/release/org/springframework/spring
官方文档：https://docs.spring.io/spring-framework/docs/5.2.0.RELEASE/spring-framework-reference/index.html
maven包：

spring-webmvc
spring-jdbc

1.2 优点

Spring是一个开源的免费框架
Spring是一个轻量级的，非入侵式的框架
控制反转(IOC)，面向切面编程(AOP)
支持事务的处理，对框架整合的支持

总结：Spring是一个轻量级的控制反转(IOC)和面向切面编程(AOP)的框架

1.3 组成

1.4 扩展

现代化的Java开发：基于Spring开发

SpringBoot
- 一个快速开发的脚手架
- 基于SpringBoot可以快速开发单个微服务
- 约定大于配置
SpringCloud
- 基于SpringBoot实现

大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring及SpringMVC！承上启下的作用！

项目骨架

<?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>

2，IOC理论推导

1.UserDao接口

2.UserDapImpl实现类

3.UserService业务接口

4.UserServiceImpl业务实现类

在之前的业务中，用户的需求可能会影响原本的代码，程序员需要根据用户的需求去修改源代码！如果程序代码量十分大，修改一次的成本代价十分昂贵！

使用Set接口实现，发生了革命性的变化

private UserDao userDao;//利用set进行动态实现值的注入
public void setUserDao(UserDao userDao) {
	this.userDao = userDao;
}

之前，程序时主动创建对象，控制权在程序猿受伤
现在，使用set注入后，程序不再具有主动性，而是变成了被动接收对象

这种思想，从本质上解决了问题，程序猿不用再去管理对象的创建了

2.1 IOC本质

控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。在没有IoC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把二者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入(Dependenccy Injection,DI)。

3，HelloSpring

实体类：

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 + '\'' +
    			'}';
	}
}

配置文件：

<?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-->    
    <bean id="hello" class="com.lin.pojo.Hello">
        <property name="str" value="Spring"/>    
    </bean>

</beans>

测试文件：

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());    
    }
}

4，IoC创建对象方式

1.使用无参构造创建对象，默认！
2.假设我们要使用有参构造构建对象
(1)下标赋值

<bean id="user" class="com.lin.pojo.User">    
	<constructor-arg index="0" value="你好"/></constructor-arg>
</bean>

(2)类型创建

<bean id="user" class="com.lin.pojo.User">    
	<constructor-arg type="java.lang.String" value="你好"/></constructor-arg>
</bean>

(3)参数名创建

<bean id="user" class="com.lin.pojo.User">    
	<constructor-arg name="name" value="1号战士"/></constructor-arg>
</bean>

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了！

5，Spring配置说明

5.1 别名

id：bean的唯一标识符，也就是相当于对象名
class：bean对象所对应的全限定名：包名+类名
name:别名

<alias name="user" alias="u"></alias>

5.2 Bean配置

<bean id="user22" class="com.lin.pojo.User2" name="userT">
	<property name="name" value="123"/>
</bean>

5.3 import

import一般用于团队开发使用，他可以将多个配置文件导入合并为一个。
假设现在项目中有多个人开发，每个人负责不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml文件合并为一个applicationContext.xml，使用时直接使用总的配置。

<import resource="beans.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>

6， DI(Dependency Injection)依赖注入

6.1 构造器注入

constructor-arg，前面已经论述

6.2 Set方式注入[重点]

依赖注入：Set注入
- 依赖：bean对象的创建依赖于容器
- 注入：bean对象中的所有属性，由容器来注入

[环境搭建]
1.复杂类型

public class Address {
    private String address;
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
}

2.真实测试对象

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbies;
    private Map<String,String> cards;
    private Set<String> games;
    private Properties info;
    private String wife;
    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> getCards() {
        return cards;
    }

    public void setCards(Map<String, String> cards) {
        this.cards = cards;
    }

    public Set<String> getGames() {
        return games;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public Properties getInfo() {
        return info;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address +
                ", books=" + Arrays.toString(books) +
                ", hobbies=" + hobbies +
                ", cards=" + cards +
                ", games=" + games +
                ", info=" + info +
                ", wife='" + wife + '\'' +
                '}';
    }

3.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.lin.pojo.Address">
        <property name="address" value="北京"/>
    </bean>
    <bean id="student" class="com.lin.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="hobbies">
            <list>
                <value>听歌</value>
                <value>敲代码</value>
                <value>看电影</value>
            </list>
        </property>
        <!--第五种，Map注入-->
        <property name="cards">
            <map>
                <entry key="身份证" value="520"/>
                <entry key="银行卡" value="88888888"/>
            </map>
        </property>
        <!--第六种，Set注入-->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>ES5</value>
            </set>
        </property>
        <!--第七种，null注入-->
        <property name="wife">
            <null/>
        </property>
        <!--第八种，Properties注入-->
        <property name="info">
            <props>
                <prop key="学号">20190525</prop>
                <prop key="性别">男</prop>
                <prop key="姓名">小明</prop>
            </props>
        </property>
    </bean>
</beans>

4.测试类

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());
    }
}

完善注入信息

6.3 拓展方式注入

我们可以使用p命名空间和c命名空间进行注入
p命名：取代property

要在xml配置文件中加入

xmlns:p="http://www.springframework.org/schema/p"

c命名：取代constructor-arg

要在xml配置文件中加入

xmlns:c="http://www.springframework.org/schema/c"

<bean id="student2" class="com.lin.pojo.student2" p:name="剑圣" p:age="25"/>
<bean id="student3" class="com.lin.pojo.student3" c:name="龙龟" c:age="85"/>

6.4 Bean的作用域

1.单例模式(Spring默认机制)
bean一旦设置，所有取出的类都是同一个

<bean id="student2" class="com.lin.pojo.student2" p:name="剑圣" p:age="25" scope="singletion"/>

这两个user地址都是同一个

2.原型模式

<bean id="student3" class="com.lin.pojo.Student3" c:name="龙龟" c:age="85" scope="prototype"/>

这两个user地址都不是同一个

每次从容器中get时，都会获得一个新对象。

@Test
    public void testBeans2() {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans2.xml");
        Student2 student2 = (Student2) context.getBean("student2");
        Student2 isStudent2 = (Student2) context.getBean("student2");
        Student3 student3 = (Student3) context.getBean("student3");
        Student3 isStudent3 = (Student3) context.getBean("student3");
        System.out.println(student3.toString() + " " + student2.toString());
        System.out.println(student2 == isStudent2);//true
        System.out.println(student3 == isStudent3);//false
    }

3.其余request,session，application这些只能在web开发中使用到。

7， Bean的自动装配

自动装配是Spring满足bean依赖的一种方式
Spring会在上下文中自动寻找，并自动给bean装配属性

在Spring中有三种装配方式
1.在xml中显式配置
2.在java中现实配置
3.隐式的自动装配bean(重要)

7.1 测试

1.环境搭建：一个人有两个宠物

7.2 自动装配

<bean id="cat" class="com.lin.pojo.Cat"></bean>
<bean id="dog" class="com.lin.pojo.Dog"></bean>
<bean id="people" class="com.lin.pojo.People" autowire="byName">
    <property name="name" value="先生"></property>
</bean>

小结：

byName，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致。
byType，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致。

7.3 使用注解实现自动装配

jdk1.5支持的注解，Spring2.5就支持注解了
使用注解须知：
1.导入约束:context约束
2.配置注解的支持

<?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
public @interface Autowired {
    boolean required() default true;
}

@Qualifier(value=…)
既无法通过byType自动装配也无法通过byName自动装配，可以通过Qualifier直接指定。

public class Person {
    private String name;
    @Resource(name = "cat895")
    private Cat cat;
    @Autowired
    @Qualifier(value = "dog222")
    private Dog dog;
}

小结：
@Resourse和@Autowired区别：

都是用来自动装配的，都可以放在属性字段上
@Autowired通过byType实现，找不到再通过byName
@Resoutce默认通过byName方式实现，如果找不到名字，则通过byType实现
执行顺序不同：@Autowired

8，使用注解开发

使用注解需要导入context约束，增加注解的支持
1.bean

@Component
public class User {
    public String name = "剑圣";
}

2.属性如何注入

//组件，放在类上说明这个类已经被Spring管理，就是bean！
@Component
public class User {
    //相当于property中设置value
    @Value("剑圣")
    public String name;
}

3.衍生的注解
@Component有几个衍生注解，我们在web开发中会按照mvc三层架构分层

dao [@Repository]
pojo [@Component]
service [@Service]
controller [@Controller]

这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配bean
4.自动装配置
@Autowired
@Qualified
@Resource
5.作用域

@Component
@Scope("singleton")
public class User {
    //相当于property中设置value    
    @Value("剑圣")    
    private String name;
}

6.小结
xml与注解：

xml更加万能，适用于任何场合！维护简单方便
注解不是自己类使用不了，维护相对复杂！

xml与注解最佳实践：

xml用来管理bean
注解只负责完成属性的注入
我们在使用的过程中，只需要注意一个问题：必须让注解生效，开启注解支持

9，使用Java方式配置Spring

可以完全不使用Spring的xml配置，全权交给Java实现！
JavaConfig是Spring的一个子项目，在Spring4之后变为核心功能。

实体类：

@Component
public class User {
    @Value("先生")
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

配置类：

//@Configuration代表这是一个配置类，就和我们之前看的beans.xml一样
@Configuration
@ComponentScan("com.lin.pojo")
public class LinConfig {
    //注册一个bean，就相当于我们之前写的一个bean标签
    //这个方法的名字，就相当于bean标签中的id属性
    //这个方法的返回值，就相当于bean标签中的class属性
    @Bean
    public User getUser(){
        return new User();
    }
}

测试类：

@Test
    public void test(){
        ApplicationContext context = new AnnotationConfigApplicationContext(LinConfig.class);
        User user = (User) context.getBean("getUser");
        System.out.println(user.getName());
    }

10，代理模式

为什么要学习代理模式？这是SpringAOP的底层实现！[SpringAOP和SpringMVC]

静态代理
动态代理

10.1 静态代理

角色分析：

抽象角色：一般会使用接口或者抽象类来解决
真实角色：被代理的角色
代理角色：代理真实角色，代理真实角色后，一般会做一些附属操作
客户：访问代理对象的人

代码步骤：
1.接口

public interface Rent {
	public void rent();
}

2.真实角色

public class Host implements Rent{
	@Override    
    public void rent() {
    	System.out.println("房东要出租房子");    
    }
}

3.代理角色

public class Proxy implements Rent {
	private Host host;    
	public Proxy() {}    
	public Proxy(Host host) {
		this.host = host;    
	}    
	@Override    
	public void rent() {
		seeHouse();        
		host.rent();        
		free();
	}    
	//看房    
	public void seeHouse() {
		System.out.println("中介带你看房子");    
	}    
	//收中介费    
	public void fare() {
		System.out.println("收中介费");    
	}
}

4.客户端访问代理角色

public class Client {
	public static void main(String[] args) {
        Host host = new Host();        
        Proxy proxy = new Proxy(host);        
        proxy.rent();    
    }
}

代理模式的好处：

可以使真是角色的操作更加纯粹！不用去关注一些公共的业务。
公共也就是交给代理角色！实现了业务的分工！
公共业务发生扩展的时候，方便集中管理！
缺点：
一个真实角色就会产生一个代理角色，代码量翻倍

10.2 深入理解

1.UserService类

public interface UserService {
    void add();
    void delete();
    void update();
    void query();
}

2.UserServiceImpl类

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("查询");
    }
}

如果现在我们需要在这个类上面增加一些输出，但是改动源代码是大忌，这时候使用静态代理，在代理中初始化要代理的类，并对其进行封装实现

public class UserServiceProxy implements UserService {
    private UserServiceImpl 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 setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

10.3 动态代理

创建动态代理对象，并加入新增的日志功能

public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Object target;
    public void setRent(Object target) {
        this.target = target;
    }
    //生成动态代理类
    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
    }
    //处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质，就是使用反射机制实现！
        this.log(method.getName());//使用反射method获取到执行方法的name
        Object result = method.invoke(target, args);
        return result;
    }
    public void log(String msg){
        System.out.println("执行了"+msg+"方法！");
    }
}

测试：

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //设置要代理的对象
        pih.setRent(userService);
        //动态生成代理类
        UserService proxy = (UserService) pih.getProxy();
        proxy.update();
    }
}

动态代理的好处：

可以使真实的角色操作更加纯粹！不用去管制公共的事务。
公共交给代理角色！实现了业务的分工！
公共业务发生扩展的时候，方便集中管理！
一个动态代理类代理的是一个接口，一般就是对应的一类业务。
一个动态代理类可以代理多个类，只要实现同一个接口即可

11， AOP

11.1 什么是AOP

AOP意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。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织入，需要导入一个依赖包
aspectjweaver

<dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
            <scope>runtime</scope>
</dependency>

方式一：使用Spring的API接口

AfterLog：

public class AfterLog implements AfterReturningAdvice {
    //returnValue：返回值
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);
    }
}

Log：

public class Log implements MethodBeforeAdvice {
    //method：要执行的目标对象方法
    //args：参数
    //target：目标对象
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}

UserService:

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();
}

UserServiceImpl:

public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("增加了一个用户");
    }
    public void delete() {
        System.out.println("删除了一个用户");
    }
    public void update() {
        System.out.println("更新了一个用户");
    }
    public void select() {
        System.out.println("查询了一个用户");
    }
}

applicationContext:

<!--注册bean-->
<bean id="userService" class="com.guan.service.UserServiceImpl"/>
<bean id="log" class="com.guan.log.Log"/>
<bean id="afterLog" class="com.guan.log.AfterLog"/>
<!--方式一：使用原生Spring API接口-->
<!--配置AOP：需要导入aop约束-->
<aop:config>
    <!--切入点：expression：表达式，execution(要执行的位置！ 修饰词 返回值 类名 方法名 参数)-->
    <aop:pointcut id="pointcut" expression="execution(* com.guan.service.UserServiceImpl.*(..))"/>
    <!--执行环绕增加-->
    <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
    <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>

MyTest:

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口
        UserService userService = context.getBean("userService",UserService.class);
        userService.add();
    }
}

方式二：自定义来实现AOP

DiyPointCut：

public class DiyPointCut {
    public void before() {
        System.out.println("===========方式执行前==========");
    }
    public void after() {
        System.out.println("===========方式执行后==========");
    }
}

applicationontext.xml：

<!--方式二：自定义类-->
<bean id="diy" class="com.guan.diy.DiyPointCut"/>
<aop:config>
    <!--自定义切面，ref要引用的类-->
    <aop:aspect ref="diy">
        <!--切入点-->
        <aop:pointcut id="point" expression="execution(* com.guan.service.UserServiceImpl.*(..))"/>
        <!--通知-->
        <aop:before method="before" pointcut-ref="point"/>
        <aop:after method="after" pointcut-ref="point"/>
    </aop:aspect>
</aop:config>

方式三：使用注解实现！
AnnotationPointCut:

//使用注解实现AOP
@Aspect  //标注这个类是一个切面
public class AnnotationPointCut {
    @Before("execution(* com.guan.service.UserServiceImpl.*(..))")
    public void before() {
        System.out.println("方法执行前");
    }
    //在环绕增强中，我们可以给定一个函数，代表我们要获取处理切入的点
    @Around("execution(* com.guan.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        //执行方法
        jp.proceed();
        System.out.println("环绕后");
    }
}

applicationContext.xml:

<!--方式三：注解实现-->
<bean id="annotation" class="com.guan.diy.AnnotationPointCut"/>
<!--开启注解支持-->
<aop:aspectj-autoproxy/>

12，整合MyBatis

步骤：
1.导入相关jar包

junit
mybatis
mysql
spring-webmv
spring-jdb
aspetjweaver
mybatis-spring[新包]
2.编写配置文件
3.测试

12.1 回忆mybatis

1.编写实体类
2.编写核心配置文件
3.编写接口
4.编写Mapper.xml文件
5.测试

12.2 Mybatis-Spring

1.编写数据源配置
2.sqlSessionFactory
3.sqlSessionTemplat
4.给接口加实现类
5.将实现类注入spring中
6.测试使用
在这里插入图片描述

UserMapper:

public interface UserMapper {
    List<User> getUser();
}

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.lin.mappers.UserMapper">
    <select id="getUser" resultType="user">
        select *
        from mybatis.user;
    </select>
</mapper>

UserMapperImpl

public class UserMapperImpl implements UserMapper{
    private SqlSessionTemplate sqlSessionTemplate;
    public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSessionTemplate = sqlSessionTemplate;
    }
    public List<User> getUser() {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.getUser();
    }
}

mybatis-config:

<?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.lin.pojo"/>
    </typeAliases>
</configuration>

spring-dao

<?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"
       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/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;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/guan/mapper/*.xml"/>
    </bean>
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
    <bean id="userMapper" class="com.lin.mappers.UserMapperImpl">
        <property name="sqlSessionTemplate" ref="sqlSession"/>
    </bean>
</beans>

MyTest:

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        List<User> users = userMapper.getUser();
        for (User user : users) {
            System.out.println(user);
        }
    }
}

扩展方式：
UserMapperImpl2：

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
    public List<User> getUser() {
        SqlSession sqlSession = getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.getUser();
    }
}

spring-dao:

<bean id="userMapper2" class="com.lin.mappers.UserMapperImpl2">
    <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>

13，声明式事务

13.1 回顾事务

把一组业务当成一个业务来做：要么都成功，要么都失败
事务在项目开发中十分重要，涉及到数据的一致性问题，不能马虎。
确保完整性和一致性

事务ACID原则

原子性
一致性
持久性：一旦提交，无法更改
隔离性：多个业务可能操作同一个资源，防止数据损坏

13.2 事务类型

声明式事务
编程时事务

UserMapper:

public interface UserMapper {
    public List<User> selectUser();
    public int addUser(User user);
    public int deleteUser(int id);
}

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.guan.mapper.UserMapper">
    <resultMap id="userMap" type="user">
        <result property="password" column="pwd"/>
    </resultMap>
    <select id="selectUser" resultType="user" resultMap="userMap">
        select *
        from `mybatis`.user;
    </select>
    <insert id="addUser" parameterType="user">
        insert into mybatis.user
        values (#{id},#{name},#{pwd});
    </insert>
    <delete id="deleteUser" parameterType="_int">
        delete
        from mybatis.user
        where id = #{id};
    </delete>
</mapper>

UserMapperImpl:

package com.guan.mapper;
import com.guan.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.List;
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper{
    public List<User> selectUser() {
        User user = new User(9, "雷王", "123456");
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        mapper.addUser(user);
        mapper.deleteUser(9);
        return mapper.selectUser();
    }
    public int addUser(User user) {
        return getSqlSession().getMapper(UserMapper.class).addUser(user);
    }
    public int deleteUser(int id) {
        return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
    }
}

spring-dao:

<?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:tx="http://www.springframework.org/schema/tx"
       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/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--DataSource:使用Spring的数据源替换Mybatis的配置，c3p0 dbcp druid
    我们这里使用Spring提供的jdbc
    -->
    <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;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/guan/mapper/*.xml"/>
    </bean>
    <bean id="userMapper" class="com.guan.mapper.UserMapperImpl">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </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"/>
            <tx:method name="update"/>
            <tx:method name="query" read-only="true"/>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>
    <!--配置事务切入-->
    <aop:config>
        <aop:pointcut id="txPointCut" expression="execution(* com.guan.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>
</beans>

MyTest

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        List<User> users = userMapper.selectUser();
        for (User user : users) {
            System.out.println(user);
        }
    }
}