Spring

最新推荐文章于 2024-08-14 23:12:09 发布

z玉无心

最新推荐文章于 2024-08-14 23:12:09 发布

阅读量125

点赞数 1

分类专栏： Java之路文章标签： java spring 5

本文链接：https://blog.csdn.net/qq_45942687/article/details/118974676

版权

Java之路专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文详细介绍了Spring框架的核心特性，包括IOC（控制反转）和AOP（面向切面编程）。讨论了Spring如何通过依赖注入降低耦合度，以及Bean的作用域。此外，还讲解了Spring与Mybatis的整合，涉及数据源配置、SqlSessionFactory、SqlSessionTemplate等。最后，提到了声明式事务管理在Spring中的应用。

摘要由CSDN通过智能技术生成

1、Spring

1.1、简介

Spring：—》给软件行业带来了春天
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#learn

正文文档：https://www.docs4dev.com/docs/zh/spring-framework/5.1.3.RELEASE/reference

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.8</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.8</version>
</dependency>

1.2、优点

Spring是一个开源免费的框架(容器)
Spring是一个轻量级的，非入侵式的框架【导入不会影响本身的项目】
控制反转（IOC），面向切面编程（AOP）
支持事物的处理，对框架整合的支持！！

总结一句话：Spring就是一个轻量级的控制（IOC）和面向切面编程的框架（AOP）

1.3、组成

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZolpQfkh-1626867872234)(…/AppData/Roaming/Typora/typora-user-images/image-20210717094032651.png)]

1.4、扩展

在Spring的官网介绍：现代化的java开发！说白了就是基于Spring的开发！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yRRiNDQU-1626867872238)(…/AppData/Roaming/Typora/typora-user-images/image-20210717094247834.png)]

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

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

弊端：Spring发展太久了违背了最初的理念，配置繁琐

2、IOC理论推导

UserDao接口
UserDaoImpl实现类
UserService业务接口
UserServiceImpl业务实现类

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

我们利用一个set接口实现，已经发生了革命性的变化啊！！

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

之前，程序主动创建对象！控制权在程序员手上！！
使用set注入后，程序不再具有主动性，而是变成了被动的接受对象!!

这种思想，从本质上解决了问题，我们程序员不用再去管理对象的创建了。系统的耦合性大大降低了，-可以更加专注的在业务实现上！！这是IOC的原型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hwb3zFHq-1626867872241)(…/AppData/Roaming/Typora/typora-user-images/image-20210717104654512.png)]

IOC本质

控制反转IOC（Inversion of Control)，是一种设计思想，DI（依赖注入）是实现IOC的一种方法，也有人认为DI只是ioc的另一种说法.没有ioc的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制后转后将对象的船创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了

采用XML方式配置Bean的时候，Bean定义信息是和实现分离的，而采用注解的方式把两者和为一体，Bean的定义信息直接以注解的形式定义在实现类中从而达到了零配置的目的。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IOC容器，实现方法是依赖注入（Dependency Injection，DI）

3、helloSpring

实体类 Hello

package com.kun.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 + '\'' +
            '}';
    }
}

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
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--使用Spring来创建对象，在Spring这些都称为Bean

    类型   变量名 = new 类型();
    Hello hello = new Hello();

    id = 变量名
    class = new 对象

    property 相当于给对象中的属性设置一个值！

	 注意： 需要set方法 才可实现
    -->
    <bean id="hello" class="com.kun.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>
</beans>

@Test

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来创建的

反转：程序本身不创建对象，而变成被动的接受对象

依赖注入：就是liyongset方法来进行注入的

IOC是一种编程思想，由主动的编程变成了被动的接受

可以通过new ClassPathXmlApplicationContext 去浏览一下底层源码

OK，到现在，我们彻底不用再去程序中改动了，要实现不同的操作，是需要在xml配置文件中进行修改，所谓的Ioc，一句话搞定：对象由Spring来创建，管理，装配！！！

4、IOC创建对象的方式

使用无参构造创建对象，默认！！
假设我们要使用有参构造创建对象

下标赋值

<!--第一种下表，下标赋值-->
<bean id="user" class="com.kun.pojo.User">
   <constructor-arg index="0" value="小狂狂"/>
</bean>

类型【不建议使用】

<!--第二种方式：通过类型，  不建议使用-->
<bean id="user" class="com.kun.pojo.User">
    <constructor-arg type="java.lang.String" value="框框"/>
</bean>

参数名

<!--第三种方式：直接通过参数名来设置-->
<bean id="user" class="com.kun.pojo.User">
    <constructor-arg name="name" value="狂神"/>
</bean>

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

注意：这需要构造方法

5、Spring配置

5.1、别名

<!--别名，如果添加了别名，我们也可以使用别名获取到这个对象-->
    <alias name="user" alias="new_user"/>

5.2、Bean的配置

<!--
    id : bean 的唯一标识符，也就是相当于我们学的对象名
    class : bean 对象所对应的权限定名： 包名+类型
    name ： 也是别名
    -->
<bean id="userT" class="com.kun.pojo.UserT" name="user2 ,u2 u3; u4">
</bean>

5.3、import

这个import，一般用于团队开发使用，它可以将多个配置文件，导入合并为一个

假设，现在项目中有多个人开发，这三个人复制不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的！！

bean1.xml 【张三】
bean2.xml 【李四】
bean3.xml 【王五【
applicationContext.xml

使用的时候直接用总的配置就可以了

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

6、依赖注入

6.1、构造器注入

略

6.2、Set方式注入*

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

【环境搭建】

复杂类型

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

真实测试对象

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private Properties info;
}

beans.xm.【未完善】

<?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.kun.pojo.Student">
        <property name="name" value="秦疆"></property>
    </bean>

</beans>

4.测试

   public static void main(String[] args) {
       ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
       Student student = (Student) context.getBean("student");
   
       System.out.println(student.getName());
   }

完善注入信息

<?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.kun.pojo.Address">
        <property name="address" value="桂林"/>
    </bean>

    <bean id="student" class="com.kun.pojo.Student">
        <!--普通注入，value-->
        <property name="name" value="秦疆"></property>

        <!--Bean注入，ref-->
        <property name="address" ref="address"/>

        <!--数组注入，ref-->
        <property name="books">
            <array>
                <value>小说11</value>
                <value>小说22</value>
                <value>小说33</value>
            </array>
        </property>

        <!--list注入-->
        <property name="hobbys" >
            <list>
                <value>打游戏</value>
                <value>打代码</value>
                <value>听音乐</value>
            </list>
        </property>

        <!--map注入-->
        <property name="card">
            <map>
                <entry key="饭卡" value="111222"/>
                <entry key="身份证" value="111222333"/>
            </map>
        </property>

        <!--Set注入-->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>CSGO</value>
                <value>COC</value>
            </set>
        </property>

        <!--null注入-->
        <property name="wife">
            <null/>
        </property>

        <!--Properties注入-->
        <property name="info">
            <props>
                <prop key="学号">1920530</prop>
                <prop key="性别">男</prop>
            </props>
        </property>

    </bean>
</beans>

补充

<!--p命名空间注入，可以构造器注入值：property      scope:作用域-->
<!--    @Scope("prototype")//多实例，IOC容器启动创建的时候，并不会创建对象放在容器在容器当中，当你需要的时候，需要从容器当中取该对象的时候，就会创建。-->
<!--    @Scope("singleton")//单实例 IOC容器启动的时候就会调用方法创建对象，以后每次获取都是从容器当中拿同一个对象（map当中）。-->
<!--    @Scope("request")//同一个请求创建一个实例-->
<!--    @Scope("session")//同一个session创建一个实例-->
<bean id="user2" class="com.kun.pojo.User" c:name="牛牛" c:age="10" scope="singleton"/>

6.3、拓展方式注入

我们可以使用p命令空间和c命令空间进行注入

<?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命名空间注入，可以直接注入属性的值：property-->
    <bean id="user" class="com.kun.pojo.User" p:name="李白" p:age="18"/>

    <!--p命名空间注入，可以构造器注入值：property-->
    <bean id="user2" class="com.kun.pojo.User" c:name="牛牛" c:age="10"/>
</beans>

测试：

@Test
public void userTest(){
    ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
    User user = context.getBean("user2",User.class);

    System.out.println(user.toString());
}

注意点：p命名和c命名空间不能直接使用，需要到导入xml约束！

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

6.4、bean的作用域

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SZsKGqbG-1626867872244)(…/AppData/Roaming/Typora/typora-user-images/image-20210717224439201.png)]

单例模式（Spring默认机制）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iWjnudPf-1626867872246)(…/AppData/Roaming/Typora/typora-user-images/image-20210717225907868.png)]
```
<bean id="user2" class="com.kun.pojo.User" c:name="牛牛" c:age="10" scope="singleton"/>
```
原型模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oZBCxnU5-1626867872247)(…/AppData/Roaming/Typora/typora-user-images/image-20210717225843145.png)]

<!--p命名空间注入，可以构造器注入值：property      scope:作用域-->
<bean id="user2" class="com.kun.pojo.User" c:name="牛牛" c:age="10" scope="prototype"/>

其余的request、session、application 这些个只能在web开发中使用到！！

7、Bean的自动装配

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

在Spring中有三种自动装配的方式

下xml中显示的配置
在Java中显示配置
隐式的自动配置bean 【重要】

7.1、测试

环境搭建
- 一个人有两个宠物

7.2、ByName自动装配

【类里边要要相关 set】

<!--
    byName: 会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid
    -->
<bean id="people" class="com.kun.pojo.People" autowire="byName">
    <property name="name" value="狂狂"/>
</bean>

7.3、ByTepe自动装配

<!--
    byType: 会自动在容器上下文中查找，和自己对象属性类型相同的bean  
		甚至 id 都可以省略 因为byType根据类型装配
  -->
<bean id="people" class="com.kun.pojo.People" autowire="byType">
    <property name="name" value="狂狂"/>
</bean>

小结：

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

7.4、使用注解实现自动装配

jdk1.5支持的注解，Spring2.5就支持注解了！

要使用注解须知：

导入约束： 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
        http://www.springframework.org/schema/beans/spring-beans.xsd
       
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>
</beans>

@Autowired（）

直接在属性上使用即可！也可以在set方式上使用！

使用Autowired我们可以不用编写Set方法了，前是你这个自动装配的属性在IOC（Spring）容器中存在，且符合名字byName！（本质还是byName）

科普：

//如果显示定义了Autowired的required属性为false，说明这个对象可以为null否则不允许为空
@Autowired(required = false)
private Dao dao;


@nullable	字段标记了这个注解，说明这个字段可以为nul  
public People(@Nullable String name){
        this.name = name;
    }

如果@Autowired自动装配环境比较复杂的时候，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以使用@Qualifier(value = “XXX”)去配置@Autowired的使用，指定一个唯一的bean对象注入！

@Resource

public class People {
    @Resource(name = "cat")
    private Cat cat;

    @Resource(name = "dog")
    private Dao dao;
}

小结：

@Resource 和 @Autowired 的区别：

都是自动装配的，都可以放在属性字段上
@Autowired 通过 byType的方式实现必须要求这个对象存在！！！【常用】
Resource 默认通过 byName的方式实现，如果找不到名字，则通过byType实现都找不到就报错了【常用】

执行顺序不同：@Autowired通过byType的方式实现。@Resource 默认通过byName的方式实现

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
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!--注解支持  不能漏   @Autowired-->
    <context:annotation-config/>


</beans>

bean

属性如何注入

//等价  <bean id="user" class="com.kun.pojo.User"/>
@Component //组件
public class User {
    //相当于 <property name="name" value="狂神"/>
    @Value("xiao")
    public String name = "秦建";
}

衍生的注解

@Component有几个衍生注解，我们web开发中，会按照mvc三层架构分层
- dao 【@Repository】
- service 【@Service】
- controller 【@Controller】
这个四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean
自动配置装置

@Autowired : 自动装配通过类型，（名字）

如果Autowired不能唯一自动装配属性，则需要通过@Qualifier(value=“xxx”)
@Nullable : 字段标记了这个注解，说明这个字段可以为null
@Resource : 自动装配组通过名字，类型

作用域

//等价  <bean id="user" class="com.kun.pojo.User"/>
@Component //组件
@Scope("prototype")
public class User {
   //相当于 <property name="name" value="狂神"/>
   @Value("xiao")
   public String name;
}

小结

xml与注解：
- xml更加万能，适用于任何场合！维护简单方便
- 注解不是自己的类使用不了，维护相对复杂！
xml与最佳实践：
- xml用来管理bean
- 注解只负责完成属性的注入
- 我们在使用的过程中，只需要注意一个问题：必须让注解生效，就需要开启注解支持
```
    
    <context:component-scan base-package="com.kun"/>
    
    <context:annotation-config/>
```

9、使用Java的方式配置Spring

我们现在要完全不使用Spring的xml配置，全权交给java来做

javaConfig是Spring的一个子项目，在Spring4之后，他成为了核心功能

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G1jKyvio-1626867872248)(…/AppData/Roaming/Typora/typora-user-images/image-20210718155143807.png)]

实现类

package com.kun.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

//这里这个注解的意思，就是说明这个类被Spring接管了，注册到了容器中
@Component
public class User {
    private 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.kun.config;

import com.kun.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.kun.pojo")
@Import(kunConfig2.class)
public class KunConfig {

    //注册一个bean，就相当于我们之前写的一个bean标签
    //这个方法的名字，就相当于bean标签中的id标签
    //这个方法的返回值，就相当于bean标签中的class属性
    @Bean
    public User user(){
        return new User();//就是返回要注入到bean的对象
    }

}

测试类

public class MyTest {
    @Test
    public void UTest(){
        //如果完全使用了配置类方式去做，我们就只能通过AnnotationConfig 上下文来获取容器，通过配置类的class对象加载！！
        ApplicationContext config = new AnnotationConfigApplicationContext(KunConfig.class);
        User getUser = (User) config.getBean("user");
        System.out.println(getUser.getName());
    }
}

这种纯java的配置方式，在SpringBoot中随出可见！！ SSM

10、代理模式

为什么要学习代理模式？因为这就是SpringAOP的底层！【SpringAOP和SpringMVC】

代理模式的分类

静态代理
动态代理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ho5lGJz4-1626867872249)(…/AppData/Roaming/Typora/typora-user-images/image-20210719092345797.png)]

10.1、静态代理

角色分析：

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

代码步骤：

接口

//租房子
public interface Rent {
    public void rent();
}

真实角色

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

代理角色

public class Proxy implements Rent{
    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    public void rent() {
        host.rent();
    }

    //看房
    public void seeHouse(){
        System.out.println("看房子");
    }

    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

客户端访问代理模式

public static void main(String[] args) {
    //房东要租房子
    Host host = new Host();

    //代理，中介帮房东收房子，但是？ 代理角色一般会有一些附属操作！！
    Proxy proxy = new Proxy(host);

    //不用面对房东，直接找中介出租房子即可！！！！
    proxy.rent();
    
}

代理模式的好处：

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

缺点：

一个真实角色就会产生一个代理角色；代码量会翻倍~ 开发效率会变低

10.2、加深理解

代码

UserService

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

UserServiceImpl

package com.kun.demo02;

public class UserServiceImpl implements UserService{
    public void add() {
        System.out.println("add了一个用户");
    }

    public void delete() {
        System.out.println("delete了一个用户");
    }

    public void update() {
        System.out.println("update了一个用户");
    }

    public void query() {
        System.out.println("query了一个用户");
    }

    //1.改动原有的业务代码，在公司中是大忌！！
}

UserServiceProxy

package com.kun.demo02;

public class UserServiceProxy implements UserService{
    private UserServiceImpl userService;

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

    public void add() {
        log("add");
        System.out.println("add了一个用户");
    }

    public void delete() {
        log("delete");
        System.out.println("delete了一个用户");
    }

    public void update() {
        log("update");
        System.out.println("update了一个用户");
    }

    public void query() {
        log("query");
        System.out.println("query了一个用户");
    }

    //日志方法
    public void log(String msg){
        System.out.println("【debug】 使用了"+msg+"方法");
    }
}

测试类

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        UserServiceProxy userServiceProxy = new UserServiceProxy();
        userServiceProxy.setUserService(userService);
        userServiceProxy.add();
    }
}

聊聊 AOP

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mbE4dFT8-1626867872251)(…/AppData/Roaming/Typora/typora-user-images/image-20210719101858961.png)]

10.3、动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写好的！！
动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口—JDK动态代理【我们在这里使用】
- 基于类：cglib
- Java字节码实现：javasist

需要了解俩个类：Proxy：代理，InvocationHandler：调用处理程序

动态代理的好处：

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

11、AOP

11.1、什么是AOP

AOP（Aspect Oriented Progrogramming）意为：面向切面编程，通过预编译方式和运行代理实现程序功能的统一维护技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各个部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

通俗易懂

要理解切面编程，就需要先理解什么是切面。用刀把一个西瓜分成两瓣，切开的切口就是切面；炒菜，锅与炉子共同来完成炒菜，锅与炉子就是切面。web层级设计中，web层->网关层->服务层->数据层，每一层之间也是一个切面。编程中，对象与对象之间，方法与方法之间，模块与模块之间都是一个个切面。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NV9v0665-1626867872252)(…/AppData/Roaming/Typora/typora-user-images/image-20210719205630374.png)]

11.2、AOP在Spring中的作用

提供声明事物；允许用户自定义切面

横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事物等等…
切面（ASPECT）：横切关注点被模块化的特殊对象。即，他是一个类【切入点 + 通知】
通知（ADvice）：切面必须要完成的工作。即，他是类的一个方法
目标（Target）：被通知的对象
代理（Proxy）：向目标对象应用通知之后创建的对象
切入点（PointCut）：切面通知执行的”地点“定义
连接点（JoinPoint）：与切入点匹配的执行点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lPHfKYix-1626867872253)(…/AppData/Roaming/Typora/typora-user-images/image-20210719210610778.png)]

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1nSWtBpn-1626867872254)(…/AppData/Roaming/Typora/typora-user-images/image-20210719210740135.png)]

即AOP在不改变原有代码的情况下，去增加新的功能。

11.3使用Spring实现AOP

【重点】使用AOP织入，需要导入一个依赖包！！

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
    <scope>runtime</scope>
</dependency>

方式一：使用Spring 的API接口【主要SpringAPI接口实现】

方式二：自定义来实现AOP 【主要是切面定义】

12、整合Mybatis

步骤：

导入相关jar包
- junit
- mybatis
- mysql数据库
- spring相关
- aop注入
- mybatis-spring 【new】
编写程序配置文件
测试

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.23</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.8</version>
    </dependency>

    <!--Spring操作数据库的话，还需要一个Spring-JDBC-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.2.4.RELEASE</version>
    </dependency>

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

    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.6</version>
    </dependency>
    
      <dependency>
         <groupId>org.projectlombok</groupId>
         <artifactId>lombok</artifactId>
         <version>1.18.12</version>
       </dependency>

</dependencies>

12.1、回忆mybatis

编写实体类
编写核心配置文件
编写接口
编写Mapper.xml
测试

12.2、Mybatis-spring

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1SPydoFm-1626867872256)(…/AppData/Roaming/Typora/typora-user-images/image-20210721125642328.png)]

编写数据源配置
sqlSessionFactory
SqlSessionTemplate
需要给接口加实现类【多】
将自己写给实现类，注入到Spring中
测试使用即可！！

实体类

package com.kun.pojo;
import lombok.Data;

@Data
@AllArgsConstructor//有参构造
@NoArgsConstructor//无参构造
public class User {
    private int id;
    private String name;
    private String pwd;
}

UserMapper.java

//接口
public interface UserMapper {
    public List<User> selectUser();
}

UserMapper.xml

<?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.kun.mapper.UserMapper">
    <select id="selectUser" resultType="user">
        select * from mybatis.user;
    </select>


</mapper>

UserMapperImpl.java

public class UserMapperImpl implements UserMapper {
    //我们的所有操作，都使用sqlSession来执行，在原来，现在都使用SqlSessionTemplate
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    public List<User> selectUser() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

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.kun.pojo"/>
    </typeAliases>

    <!--设置-->
<!--    <settings>-->
<!--        <setting name="" value=""/>-->
<!--    </settings>-->


</configuration>

spring-dao.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">


    <!--
    DataSource:使用Spring的数据源替换Mybatis的配置    c2p0 dbcp    druid
    我们这个里使用Spring 提供的JDBC:  org.springframework.jdbc.datasource.DriverManagerDataSource

    -->
    <bean name="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?userSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="030405"/>
    </bean>

    <!--sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--数据源： dataSource-->
        <property name="dataSource" ref="dataSource"/>
        <!--绑定Mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/kun/mapper/*.xml"/>
    </bean>

    <!--SqlSessionTemplate:就是我们使用的sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入sqlSessionFactory，因为他没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

<!--    &lt;!&ndash;&ndash;&gt;-->
<!--    <bean id="userMapper" class="com.kun.mapper.UserMapperImpl">-->
<!--        <property name="sqlSession" ref="sqlSession"/>-->
<!--    </bean>-->

</beans>

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
        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.kun.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

</beans>

测试类

public class MyTest {

    @Test
    public void test() throws IOException {

        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        List<User> userList = userMapper.selectUser();

        for (User user : userList) {
            System.out.println(user);
        }
    }

}

事物： spring-dao.xml这里边使用

<!--配置声明式事物-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <constructor-arg  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"/><!--query只读-->
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

<!--配置事物切入-->
<aop:config>
    <aop:pointcut id="txPointCut" expression="execution(* com.kun.mapper.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>

13、声明式事物

1、回顾事物

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

事物ACID原则：

原子性
一致性
隔离性
- 多个业务可能操作同一资源，防止数据损坏
持久性
- 事物一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化的写到存储器中！！

2、 spring中的事物

声明式事物：AOP
编程式事物：需要在代码中，进行事物的管理

为什么需要事物？？

如果不配置事物，可能存在数据提交不一致的情况下
如果我们不在Spirng中去配置声明事物，我们就需要在代码中手动配置事物
事物在项目的开发十分重要，涉及到数据的一致性和完整性问题，不容马虎！！！！！

ionContext context = new ClassPathXmlApplicationContext(“applicationContext.xml”);
UserMapper userMapper = context.getBean(“userMapper”, UserMapper.class);
List userList = userMapper.selectUser();

    for (User user : userList) {
        System.out.println(user);
    }
}

}


















**事物**：    spring-dao.xml这里边使用

```xml
<!--配置声明式事物-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <constructor-arg  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"/><!--query只读-->
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

<!--配置事物切入-->
<aop:config>
    <aop:pointcut id="txPointCut" expression="execution(* com.kun.mapper.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>