Spring詳解

本文轉載自查看原文 2022-03-27 23:13 534 SSM框架

1、Spring

1.1、簡介

Spring：春天------>給軟件行業帶來了春天！
2002，首次推出了Spring框架的雛形：interface21框架！
Spring框架即以interface21框架為基礎,經過重新的設計,並不斷的豐富其內涵,於2004年3月24日,發布了1.0正式版。
Rod Johnson ，Spring Framework創始人，著名作者。很難想象Rod Johnson的學歷，真的讓好多人大吃一驚，他是悉尼大學的博士，然而他的專業不是計算機，而是音樂學。
spring理念：使現有的技術更加容易使用，本身是一個大雜燴，整合了現有的技術框架！
SSH ：Struct2 + Spring + Hibernate！
SSM ：SpringMVC + Spring + Mybatis！

官網：https://docs.spring.io/spring-framework/docs/current/reference/html/overview.html#overview

官方下載地址：https://repo.spring.io/ui/native/release/org/springframework/spring

GitHub：https://github.com/spring-projects/spring-framework

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

1.2、優點

Spring是一個開源的免費的框架（容器）！
Spring是一個輕量級的、非入侵式的框架！
控制反轉（IOC），面向切面編程（AOP）！
支持事務的處理，對框架整合的支持！

總結一句話：Spring就是一個輕量級的控制反轉（IOC）和面向切面編程（AOP）的框架！

1.3、組成

1.4、拓展

在Spring的官網有這個介紹：現代化的Java開發！說白就是基於Spring開發！

Spring Boot
- 一個快速開發的腳手架。
- 基於SpringBoot可以快速的開發單個微服務。
- 約定大於配置！
Spring Cloud
- Spring Cloud是基於Spring Boot實現的。

因為現在大多數公司都在使用SpringBoot進行快速開發，學習SpringBoot的前提，需要完全掌握Spring及SpringMVC！承上啟下的作用！

弊端：發展了太久之后，違背了原來的理念！配置十分繁瑣，人稱：“配置地獄！”

2、IOC理論推導

UserDao 接口
UserDaoImpl 實現類
UserService 業務接口
UserServiceImpl 業務實現類

在我們之前的業務中，用戶的需求可能會影響我們原來的代碼，我們需要根據用戶的需求去修改源代碼！如果程序代碼量十分大，修改一次的成本代價十分昂貴！

我們使用一個Set接口實現。已經發生了革命性的變化！

private UserDao userDao;

//利用set進行動態實現值的注入！
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}
=========================================
public static void main(String[] args) {
    
    //用戶實際調用的是業務層，dao層它們不需要接觸！
    UserService userService = new UserServiceImpl();
    ((UserServiceImpl) userService).setUserDao(new UserDaoMysqlImpl());
    userService.getUser();
}

之前，程序是主動創建對象！控制權在程序員手上！
使用了set注入后，程序不再具有主動性，而是變成了被動的接收對象！

這種思想，從本質上解決了問題，我們程序員不用再去管理對象的創建了。系統的耦合性大大降低~。可以更加專注在業務的實現上！這是IOC的原型！

IOC本質

控制反轉IoC(Inversion of Control)，是一種設計思想，DI(依賴注入)是實現IoC的一種方法，也有人認為DI只是IoC的另一種說法。沒有IoC的程序中，我們使用面向對象編程，對象的創建與對象間的依賴關系完全硬編碼在程序中，對象的創建由程序自己控制，控制反轉后將對象的創建轉移給第三方，個人認為所謂控制反轉就是：獲得依賴對象的方式反轉了。

采用XML方式配置Bean的時候，Bean的定義信息是和現實分離的，而采用注解的方式可以把兩者合為一體，Bean的定義信息直接以注解的形式定義在實現類中，從而達到了零配置的目的。

控制反轉是一種通過描述（XML或注解）並通過第三方去生產或獲取特定對象的方式。在Spring中實現控制反轉的是IoC容器，其實現方法是依賴注入（Dependency Injection,DI）。

3、HelloSpring

導入Jar包

注：spring需要導入commons-logging進行日志記錄，我們利用maven，它會自動下載對應的依賴項

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

編寫代碼

編寫第一個Hello實體類

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

編寫我們的spring文件，這里我們命名為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就是java對象，由Spring創建和管理
	使用Spring來創建對象，在Spring這些都成為Bean

    類型 變量名 = new 類型();
    Hello hello = new Hello();
    bean = 對象    new Hello();

    id = 變量名
    class = new 的對象；
    property 相當於給對象中的屬性設置一個值！

    -->
    <bean id="hello" class="com.kuang.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());
    }
}

思考

Hello對象是誰創建的？ hello對象是由Spring創建的
Hello對象的屬性是怎么設置的？hello對象的屬性是由Spring容器設置的

這個過程就叫控制反轉：

控制：誰來控制對象的創建，傳統應用程序的對象是由程序本身控制創建的，使用Spring后，對象是由Spring來創建的
反轉：程序本身不創建對象，而變成被動的接收對象

依賴注入：就是利用set方法來進行注入的。

IOC是一種編程思想，由主動的編程編程被動的接收

可以通過newClassPathXmlApplicationContext去瀏覽一下底層源碼。

4、IOC創建對象的方式

使用無參構造創建對象，默認！

假設我們要使用有參構造創建對象。

下標賦值

<!--第一種，下標賦值！-->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg index="0" value="狂神說Java"/>
</bean>

類型

<!--第二種方式：通過類型創建，不建議使用-->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg type="java.lang.String" value="qinjiang"/>
</bean>

參數名

<!--第三種，直接通過參數名來設置-->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg name="name" value="秦疆"/>
</bean>

總結：在配置文件加載的時候，容器中管理的對象就已經初始化了

5、Spring配置

5.1、別名

<!--別名發，如果添加了別名，我們也可以使用別名獲取到這個對象-->
<alias name="user" alias="userNew"/>

5.2、Bean的配置

<!--
    id : bean 的唯一標識符，也就是相當於我們學的對象名
    class : bean 對象所對應的全限定名 ： 包名 + 類型
    name : 也是別名，而且name 可以同時取多個別名
    -->
<bean id="userT" class="com.kuang.pojo.UserT" name="user2,u2 u3;u4">
    <property name="name" value="西部開源"/>
</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依賴注入

6.1、構造器注入

前面已經說過了

6.2、Set方式注入【重點】

依賴注入：Set注入！
- 依賴：bean對象的創建依賴於容器
- 注入：bean對象中的所有屬性，由容器來注入！

【環境搭建】

復雜類型

public class Address {

    private String address;
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.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.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.kuang.pojo.Student">
        <!--第一種，普通值注入，value-->
        <property name="name" value="qinjiang"/>
    </bean>

</beans>

測試類

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

完善注入信息

<?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.kuang.pojo.Address">
        <property name="address" value="西安"/>
    </bean>

    <bean id="student" class="com.kuang.pojo.Student">
        <!--第一種，普通值注入，value-->
        <property name="name" value="qinjiang"/>

        <!--第二種，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="card">
            <map>
                <entry key="身份證" value="111111222222223333"/>
                <entry key="銀行卡" value="123123123123123123"/>
            </map>
        </property>

        <!--Set-->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>COC</value>
                <value>BOB</value>
            </set>
        </property>

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

        <!--Properties-->
        <property name="info">
            <props>
                <prop key="driver">20190525</prop>
                <prop key="url">男</prop>
                <prop key="username">root</prop>
                <prop key="password">123456</prop>
            </props>
        </property>
    </bean>

</beans>

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.kuang.pojo.User" p:name="qinjiang" p:age="18"/>

    <!--c命名空間注入，通過構造器注入：constructor-args-->
    <bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="kuangshen"/>

</beans>

測試：

@Test
public void test2(){
    ApplicationContext context = new ClassPathXmlApplicationContext("userbean.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"

6.4、bean的作用域

單例模式（Spring默認機制）

<bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="kuangshen" scope="singleton"/>

原型模式：每次從容器中get的時候，都會產生一個新對象！

<bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/>

其余的request、session、application這些個只能在web開發中使用到！

7、Bean的自動裝配

自動裝配是Spring滿足bean依賴的一種方式！
Spring會在上下文中自動尋找，並自動給bean裝配屬性！

在Spring中有三種裝配的方式

在xml中顯示的配置
在java中顯示配置
隱式的自動裝配bean 【重要】

7.1、測試

環境搭建
- 一個人有兩個寵物！

7.2、ByName自動裝配

<!--
    byName: 會自動在容器上下文查找，和自己對象set方法后面的值對應的 beanid！
    -->
<bean id="people" class="com.kuang.pojo.People" autowire="byName">
    <property name="name" value="kuangshen"/>
</bean>

7.3、ByType自動裝配

<bean class="com.kuang.pojo.Cat"/>
<bean class="com.kuang.pojo.Dog"/>

<!--
    byName: 會自動在容器上下文查找，和自己對象set方法后面的值對應的 beanid！
    byType: 會自動在容器上下文查找，和自己對象屬性類型相同的bean！
    -->
<bean id="people" class="com.kuang.pojo.People" autowire="byType">
    <property name="name" value="kuangshen"/>
</bean>

小結：

byname的時候，需要保證所有bean的id唯一，並且這個bean需要和自動注入的屬性的set方法的值一致！
bytype的時候，需要保證所有bean的class唯一，並且這個bean需要和自動注入的屬性的類型一致！

7.4、使用注解實現自動裝配

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

The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML.

要使用注解須知：

導入約束：context約束

配置注解的支持：context:annotation-config/

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

</beans>

@Autowired

直接在屬性上使用即可！也可以在set方法上使用！

使用Autowired我們可以不用編寫Set方法了，前提是你這個自動裝配的屬性在IOC（Spring）容器中存在，通過byType，再通過byname查找！

科普：

@Nullable    字段標記了這個注解，說明這個字段可以為null；

public @interface Autowired {
    boolean required() default true;
}

測試代碼

public class People {

    private String name;
    @Autowired
    private Dog dog;
    //如果顯示定義了Autowired的required屬性為false，說明這個對象可以為null，否則不允許為空
    @Autowired(required = false)
    private Cat cat;
}

如果@Autowired自動裝配的環境比較復雜，自動裝配無法通過一個注解【@Autowired】完成的時候，我們可以使用@Qualifier(value="xxx")去配合@Autowired的使用，指定一個唯一的bean對象注入！

public class People {

    private String name;
    @Autowired
    @Qualifier(value="dog222")
    private Dog dog;
    //如果顯示定義了Autowired的required屬性為false，說明這個對象可以為null，否則不允許為空
    @Autowired
    private Cat cat;
}

@Resource注解

public class People {
    
    private String name;
    @Resource(name="dog222")
    private Dog dog;
    //如果顯示定義了Autowired的required屬性為false，說明這個對象可以為null，否則不允許為空
    @Resource
    private Cat cat;
}

小結：

@Resource和@Autowired的區別：

都是用來自動裝配的，都可以放在屬性字段上
@Autowired通過byType方式實現，再通過byname查找，必須要求這個對象存在！ 【常用】
@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
        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>

bean

屬性如何注入

@Component
public class User {

    public String name;

    //相當於 <property name="name" value="kuangshen"/>
    @Value("kuangshen")
    public void setName(String name) {
        this.name = name;
    }
}

衍生的注解

@Component 有幾個衍生注解，我們在web開發中，會按照mvc三層架構分層！
- dao 【@Repository】
- service 【@Service】
- controller 【@Controller】
  
  這四個注解功能都是一樣的，都是代表將某個類注冊到Spring中，裝配Bean

自動裝配

- @Autowired : 自動裝配通過類型，然后名字
    如果Autowired不能唯一裝配上屬性，則需要通過@Qualifier(value="xxx")
- @Nullable    字段標記了這個注解，說明這個字段可以為null；
- @Resource  : 自動裝配通過名字，然后類型
- @Component : 組件，放在類上，說明這個類被Spring管理了，就是bean！

作用域

@Component
@Scope("prototype")
public class User {


    public String name;

    //相當於 <property name="name" value="kuangshen"/>
    @Value("kuangshen")
    public void setName(String name) {
        this.name = name;
    }
}

小結

xml與注解：
- xml更加萬能，適用於任何場合！維護簡單方便
- 注解不是自己的類使用不了，維護相對復雜！
xml 與注解最佳實踐：
- xml用來管理bean；
- 注解只負責完成屬性的注入；
- 我們在使用的過程中，只需要注意一個問題：必須讓注解生效，就需要開啟注解的支持
```

<context:component-scan base-package="com.kuang"/>
<context:annotation-config/>
```

9、使用Java的方式配置Spring

我們現在要完全不使用Spring的xml配置了，全權交給Java來做！

JavaConfig 是Spring的一個子項目，在Spring 4 之后，它成為了一個核心功能！

實體類：

//這里這個注解的意思，就是說明這個類被Spring接管了，注冊到了容器中
@Component
public class User {
    private String name;

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

    public String getName() {
        return name;
    }

    @Value("qinjiang") //屬性注入值
    public void setName(String name) {
        this.name = name;
    }
}

配置文件：

package com.kuang.config;

import com.kuang.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.kuang.pojo")
@Import(KuangConfig2.class)
public class KuangConfig {

    //注冊一個bean ，就相當於我們之前寫的一個bean標簽
    //這個方法的名字 ，就相當於bean標簽中的id屬性
    //這個方法的返回值 ，就相當於bean標簽中的class屬性
    @Bean
    public User user(){
        return new User(); //就是返回要注入到bean的對象！
    }
}

測試類！

public class MyTest {
    public static void main(String[] args) {
        //如果完全使用了配置類方式去做，我們就只能通過 AnnotationConfig 上下文來獲取容器，通過配置類的class對象加載！
        ApplicationContext context = new AnnotationConfigApplicationContext(KuangConfig.class);
        User user = (User) context.getBean("user");

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

這種純Java的配置方式，在SpringBoot中隨處可見！

10、代理模式

為什么要學習代理模式？因為這就是SpringAOP的底層！【SpringAOP 和 SpringMVC】

代理模式的分類：

靜態代理
動態代理

10.1、靜態代理（例：房東出租房子）

角色分析：

抽象角色：一般會使用接口或者抽象類來解決
真實角色：被代理的角色
代理角色：代理真實角色，代理真實角色后，我們一般會做一些附屬操作
客戶：訪問代理對象的人！

代碼步驟：

接口

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

真實角色

//房東
public class Host implements Rent{

    @Override
    public void rent() {
        System.out.println("房東要出租房子！");
    }
}

代理角色

public class Proxy implements Rent{

    private Host host;

    public Proxy() {
    }

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

    @Override
    public void rent() {
        seeHouse();
        host.rent();
        hetong();
        fare();
    }

    //看房
    public void seeHouse(){
        System.out.println("中介帶你看房");
    }

    //簽合同
    public void hetong(){
        System.out.println("簽租賃合同");
    }

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

客戶端訪問代理角色

public class Client {

    public static void main(String[] args) {
        //房東要租房子
        Host host = new Host();
        //代理，中介幫房東租房子，但是呢？代理一般會有一些附屬操作！
        Proxy proxy = new Proxy(host);

        //你不用面對房東，直接找中介租房即可！
        proxy.rent();
    }
}

代理模式的好處：

可以使真實角色的操作更加純粹！不用去關注一些公共的業務
公共業務就交給代理角色！實現了業務的分工！
公共業務發生擴展的時候，方便集中管理！

缺點：

一個真實角色就會產生一個代理角色；代碼量會翻倍_{開發效率會變低}

10.2、加深理解

代碼：對應 08-demo02；

public interface UserService {
    void add();
    void delete();
    void update();
    void query();
}
==============================================
//真實對象
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("查詢了一個用戶");
    }

    //1.改動原有的業務代碼，在公司中是大忌
}
==============================================
public class UserServiceProxy implements UserService{

    private UserServiceImpl userserviceimpl;

    public UserServiceImpl getUserserviceimpl() {
        return userserviceimpl;
    }

    public void setUserserviceimpl(UserServiceImpl userserviceimpl) {
        this.userserviceimpl = userserviceimpl;
    }

    @Override
    public void add() {
        log("add");
        userserviceimpl.add();
    }

    @Override
    public void delete() {
        log("delete");
        userserviceimpl.delete();
    }

    @Override
    public void update() {
        log("update");
        userserviceimpl.update();
    }

    @Override
    public void query() {
        log("query");
        userserviceimpl.query();
    }

    //日志方法
    public void log(String msg){
        System.out.println("[Debug] 使用了"+msg+"方法");
    }
}
===============================================
public class Client {

    public static void main(String[] args) {
        UserServiceImpl userserviceimpl = new UserServiceImpl();
        UserServiceProxy proxy = new UserServiceProxy();

        proxy.setUserserviceimpl(userserviceimpl);

        proxy.add();
    }
}

聊聊AOP

10.3、動態代理

動態代理和靜態代理角色一樣
動態代理的代理類是動態生成的，不是我們直接寫好的！
動態代理分為兩大類：基於接口的動態代理，基於類的動態代理
- 基於接口---JDK動態代理【我們在這里使用】
- 基於類：cglib
- java字節碼實現：javassist

需要了解兩個類：Proxy：代理，InvocationHandler：調用處理程序

動態代理的好處：

可以使真實角色的操作更加純粹！不用去關注一些公共的業務
公共業務就交給代理角色！實現了業務的分工！
公共業務發生擴展的時候，方便集中管理！
一個動態代理類代理的是一個接口，一般就是對應的一類業務
一個動態代理類可以代理多個類，只要是實現了同一個接口即可！

代碼：

//租房
public interface Rent {
    public void rent();
}
===========================================
//房東
public class Host implements Rent {

    @Override
    public void rent() {
        System.out.println("房東要出租房子！");
    }
}
============================================
//等會我們會用這個類，自動生成代理類！
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("收中介費");
    }
}
====================================================
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();
    }
}

代碼改進：

//等會我們會用這個類，自動生成代理類！
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //生成得到代理類
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    //處理代理實例，並返回結果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //動態代理的本質，就是使用反射機制實現！
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }

    public void log(String msg){
        System.out.println("執行了"+msg+"方法");
    }
}
=============================================================
public class Client {
    public static void main(String[] args) {
        //真實角色
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色，不存在
        ProxyInvocationHandler pih = new ProxyInvocationHandler();

        pih.setTarget(userService);//設置要代理的對象
        //動態生成代理類
        UserService proxy = (UserService) pih.getProxy();

        proxy.query();

    }
}

11、AOP

11.1、什么是AOP

AOP（Aspect Oriented Programming）意為：面向切面編程，通過預編譯方式和運行期動態代理實現程序功能的統一維護的一種技術。AOP是OOP的延續，是軟件開發中的一個熱點，也是Spring框架中的一個重要內容，是函數式編程的一種衍生范型。利用AOP可以對業務邏輯的各個部分進行隔離，從而使得業務邏輯各部分之間的耦合度降低，提高程序的可重用性，同時提高了開發的效率。

11.2、AOP在Spring中的作用

提供聲明式事務；允許用戶自定義切面

橫切關注點：跨越應用程序多個模塊的方法或功能。即是，與我們業務邏輯無關的，但是我們需要關注的部分，就是橫切關注點。如日志 , 安全 , 緩存 , 事務等等 ....
切面（ASPECT）：橫切關注點被模塊化的特殊對象。即，它是一個類。
通知（Advice）：切面必須要完成的工作。即，它是類中的一個方法。
目標（Target）：被通知對象。
代理（Proxy）：向目標對象應用通知之后創建的對象。
切入點（PointCut）：切面通知執行的 “地點”的定義。
連接點（JointPoint）：與切入點匹配的執行點。

SpringAOP中，通過Advice定義橫切邏輯，Spring中支持5種類型的Advice:

即 AOP 在不改變原有代碼的情況下 , 去增加新的功能。

11.3、使用Spring實現AOP

【重點】使用AOP注入，需要導入一個依賴包！

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

方式一：使用Spring的API接口【主要是SpringAPI接口實現】

<?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.kuang.service.UserServiceImpl"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>
    <bean id="log" class="com.kuang.log.Log"/>

    <!--方式一:使用原生Spring API接口-->
    <!--配置aop:需要導入aop的約束-->
    <aop:config>
        <!--切入點：expression:表達式，execution(要執行的位置！ * * * * *) 修飾詞 類 方法名 參數-->
        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>

        <!--執行環繞增加!-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

public interface UserService {

    void add();
    void delete();
    void update();
    void select();
}
============================================
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("查詢了一個用戶");
    }
}
=============================================
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);
    }
}
==============================================
public class Log implements MethodBeforeAdvice {

    //method: 要執行的目標對象的方法
    //object: 參數
    //target: 目標對象
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被執行了");
    }
}
==============================================
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 【主要是切面定義】

<?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.kuang.service.UserServiceImpl"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>
    <bean id="log" class="com.kuang.log.Log"/>

    <!--方式一:使用原生Spring API接口-->
    <!--配置aop:需要導入aop的約束-->
<!--    <aop:config>-->
<!--        &lt;!&ndash;切入點：expression:表達式，execution(要執行的位置！ * * * * *) 修飾詞 類 方法名 參數&ndash;&gt;-->
<!--        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>-->
<!--        &lt;!&ndash;執行環繞增加!&ndash;&gt;-->
<!--        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>-->
<!--        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>-->
<!--    </aop:config>-->

    <!--方式二: 自定義類-->
    <bean id="diy" class="com.kuang.diy.DiyPointCut"/>

    <aop:config>
        <!--自定義切面, ref 要引用的類-->
        <aop:aspect ref="diy">
        <!--切入點  execution(返回類型 包名(類名) 方法名)-->
        <aop:pointcut id="point" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
        <!--通知-->
        <aop:before method="before" pointcut-ref="point"/>
        <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>

</beans>

public class DiyPointCut {

    public void before(){
        System.out.println("=========方法執行前=========");
    }
    public void after(){
        System.out.println("=========方法執行后=========");
    }
}
============================================================
public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //動態代理代理的是接口:注意點
        UserService userService = context.getBean("userService", UserService.class);

        userService.add();
    }
}

方式三：使用注解實現！

<?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.kuang.service.UserServiceImpl"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>
    <bean id="log" class="com.kuang.log.Log"/>

    <!--方式三：-->
    <bean id="annotationPointCut" class="com.kuang.diy.AnnotationPointCut"/>
    <!--開啟注解支持！ JDK(默認 proxy-target-class="false") cglib(proxy-target-class="true")-->
    <aop:aspectj-autoproxy proxy-target-class="false"/>


    <!--方式一:使用原生Spring API接口-->
    <!--配置aop:需要導入aop的約束-->
<!--    <aop:config>-->
<!--        &lt;!&ndash;切入點：expression:表達式，execution(要執行的位置！ * * * * *) 修飾詞 類 方法名 參數&ndash;&gt;-->
<!--        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>-->
<!--        &lt;!&ndash;執行環繞增加!&ndash;&gt;-->
<!--        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>-->
<!--        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>-->
<!--    </aop:config>-->

    <!--方式二: 自定義類-->
<!--    <bean id="diy" class="com.kuang.diy.DiyPointCut"/>-->

<!--    <aop:config>-->
<!--        &lt;!&ndash;自定義切面, ref 要引用的類&ndash;&gt;-->
<!--        <aop:aspect ref="diy">-->
<!--        &lt;!&ndash;切入點  execution(返回類型 包名(類名) 方法名)&ndash;&gt;-->
<!--        <aop:pointcut id="point" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>-->
<!--        &lt;!&ndash;通知&ndash;&gt;-->
<!--        <aop:before method="before" pointcut-ref="point"/>-->
<!--        <aop:after method="after" pointcut-ref="point"/>-->
<!--        </aop:aspect>-->
<!--    </aop:config>-->

</beans>

//方式三：使用注解方式實現AOP
@Aspect //標注這個類是一個切面
public class AnnotationPointCut {

    @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("=====方法執行前=====");
    }

    @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("=====方法執行后=====");
    }

    //在環繞增強中，我們可以給定一個參數，代表我們要獲取並處理切入的點；
    @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("環繞前");

        System.out.println("signature:"+jp.getSignature());//獲得簽名

        //執行方法
        Object proceed = jp.proceed();//過濾

        System.out.println("環繞后");
        System.out.println(proceed);
    }
}
=========================================================
public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //動態代理代理的是接口:注意點
        UserService userService = context.getBean("userService", UserService.class);

        userService.add();
    }
}

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.16</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.9</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.17</version>
    </dependency>
    <!--Spring操作數據庫的話，還需要一個spring-jdbc-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.3.16</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.9</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.7</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.22</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.9</version>
    </dependency>
</dependencies>

編寫配置文件
測試

12.1、回憶mybatis

編寫實體類
編寫核心配置文件
編寫接口
編寫Mapper.xml
測試

12.2、MyBatis-Spring

編寫數據源配置
sqlSessionFactory
sqlSessionTemplate
需要給接口加實現類
將自己寫的實現類，注入到Spring中
測試使用即可！

方式一：

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

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

</configuration>
<!--============================================================-->
<?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的配置 c3p0 dbcp druid
    我們這里使用Spring提供的JDBC : org.springframework.jdbc.datasource
    -->
    <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?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=true&amp;serverTimezone=GMT"/>
        <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/kuang/mapper/*.xml"/>
    </bean>

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

</beans>
<!--============================================================-->
<?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.kuang.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

</beans>

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();
    }
}
==================================================================
public class MyTest {
    @Test
    public void test() throws IOException {

        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        for (User user : userMapper.selectUser()) {
            System.out.println(user);
        }
    }
}

方式二：

<?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的配置 c3p0 dbcp druid
    我們這里使用Spring提供的JDBC : org.springframework.jdbc.datasource
    -->
    <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?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=true&amp;serverTimezone=GMT"/>
        <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/kuang/mapper/*.xml"/>
    </bean>
</beans>
<!--=======================================================-->
<?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.kuang.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>
    <bean id="userMapper2" class="com.kuang.mapper.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>
</beans>
<!--===========================================================-->
<?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.kuang.mapper.UserMapper">

    <select id="selectUser" resultType="User">
        select * from mybatis.user;
    </select>
</mapper>

@Data
public class User {
    private int id;
    private String name;
    private String pwd;
}
===================================================================
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{
    @Override
    public List<User> selectUser() {
        return getSqlSession().getMapper(UserMapper.class).selectUser();
    }
}
===================================================================
public class MyTest {
    @Test
    public void test() throws IOException {

        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserMapper userMapper = context.getBean("userMapper2", UserMapper.class);
        for (User user : userMapper.selectUser()) {
            System.out.println(user);
        }
    }
}

13、聲明式事務

1、回顧事務

把一組業務當成一個業務來做；要么都成功，要么都失敗！
事務在項目開發中，十分的重要，涉及到數據的一致性問題，不能馬虎！
確保完整性和一致性；

事務ACID原則：

原子性
一致性
隔離性
- 多個業務可能操作同一個資源，防止數據損壞
持久性
- 事務一旦提交，無論系統發生什么問題，結果都不會再被影響，被持久化的寫到存儲器中！

2、spring中的事務管理

聲明式事務：AOP
編程式事務：需要在代碼中，進行事務的管理

思考：

為什么需要事務？

如果不配置事務，可能存在數據提交不一致的情況下；
如果我們不在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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           https://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/aop
                           https://www.springframework.org/schema/aop/spring-aop.xsd
                           http://www.springframework.org/schema/tx
                           https://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--DataSource:使用Spring的數據源替換Mybatis的配置 c3p0 dbcp druid
    我們這里使用Spring提供的JDBC : org.springframework.jdbc.datasource
    -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=true&amp;serverTimezone=GMT"/>
        <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/kuang/mapper/*.xml"/>
    </bean>

    <!--配置聲明式事務-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--<constructor-arg ref="dataSource"/>-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--結合AOP實現事務的織入-->
    <!--配置事務通知：-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--給哪些方法配置事務-->
        <!--配置事務的傳播特性：propagation-->
        <tx:attributes>
            <tx:method name="add" propagation="REQUIRED"/>
            <tx:method name="delete" propagation="REQUIRED"/>
            <tx:method name="update" propagation="REQUIRED"/>
            <tx:method name="select" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

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

    <bean id="userMapperImpl" class="com.kuang.mapper.UserMapperImpl">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>
</beans>
<!--===========================================================-->
<?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.kuang.mapper.UserMapper">

    <select id="selectUser" resultType="User">
        select * from mybatis.user
    </select>
    <insert id="insertUser" parameterType="User">
        insert into mybatis.user (id,name,pwd) values (#{id},#{name},#{pwd})
    </insert>
    <delete id="deleteUser">
        delete from user where id=#{id}
    </delete>
    <update id="updateUser" parameterType="User">
        update mybatis.user set (name,pwd) values(#{name},#{pwd}) where id=#{id};
    </update>
</mapper>

public interface UserMapper {

    List<User> selectUser();

    int insertUser(User user);

    int deleteUser(int id);

    int updateUser(User user);
}
=========================================================
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {

    public List<User> selectUser() {

        User user = new User(5, "小王", "123312");
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        mapper.insertUser(user);
        mapper.deleteUser(5);

        return mapper.selectUser();
    }

    public int insertUser(User user) {
        return getSqlSession().getMapper(UserMapper.class).insertUser(user);
    }

    public int deleteUser(int id) {
        return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
    }

    public int updateUser(User user) {
        return getSqlSession().getMapper(UserMapper.class).updateUser(user);
    }
}
============================================================
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {

    private int id;
    private String name;
    private String pwd;
}
=============================================================
public class MyTest {

    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
        UserMapper userMapperImpl = context.getBean("userMapperImpl", UserMapper.class);

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

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Spring(2)——Spring IoC 詳解 Spring詳解（一）----Spring框架介紹 Spring系列（四）：Spring AOP詳解 Spring(3)——裝配 Spring Bean 詳解 spring事務詳解（三）源碼詳解 Spring之AOP詳解 spring中AOP詳解 spring cache 詳解 spring AspectJ的Execution詳解 Spring的bean創建詳解