Spring的狂神說筆記

Spring5學習

Spring-Study

代碼：https://github.com/Donkequan/Spring-Study

1. 簡介

spring理念：是現有的技術更加容易使用，本身是一個大雜燴。

• SSH：Struct2 + Spring + Hibernate

• SSM: SpringMVC + Spring + Mybatis

官網： https://spring.io/projects/spring-framework#overview

官方下載： https://repo.spring.io/release/org/springframework/spring/

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

Spring Web MVC » 5.2.5.RELEASE

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

• spring是開源的免費的容器。

• spring是一個輕量級的，非入侵式的。

• 控制反轉（IOC），面向切面編程 (AOP)。

• 支持事務處理，對框架整合的支持。

總結：spring是一個輕量級的控制反轉(IOC)和面向切面編程(AOP)的框架。

2.IOC理論

1. UserDao

2. UserDaoImp

3. UserSevice

4. UserServiceImp

在之前，用戶的需求可能會影響原來的代碼。

使用一個set。

public void setUserDao(UserDao userDao){
    this.userDao = userDao;
}

• 之前是主動創建對象，控制權在程序員手上。

• 使用set之后，是被動接受對象。

3. Hello Spring

pojo中

package com.hou.pojo;
​
public class Hello {
​
    private String name;
​
    public String getName() {
        return name;
   }
​
    public void setName(String name) {
        this.name = name;
   }
​
    @Override
    public String toString() {
        return "Hello{" +
                "name='" + name + '\'' +
                '}';
   }
}

resource種

<?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 = 變量名-->
    <!--class = new的對象-->
    <!--property 相當於給對象中的屬性設值-->
    
    <bean id="hello" class="com.hou.pojo.Hello">
        <property name="name" value="Spring"/>
    </bean>
</beans>

test

import com.hou.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
​
public class Mytest {
​
    public static void main(String[] args) {
        //獲取spring上下文對象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //我們的對象下能在都在spring·中管理了，我們要使用，直接取出來就可以了
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
   }
}

bean = 對象 id = 變量名 class = new的對象 property 相當於給對象中的屬性設值

核心用set注入

第一個文件中

<?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="userdaomysql" class="com.hou.dao.UserDaoMysqlImpl"></bean>
​
    <bean id="userServiceImpl" class="com.hou.service.UserServiceImp">
        <!--ref引用spring中已經創建很好的對象-->
        <!--value是一個具體的值-->
        <property name="userDao" ref="userdaomysql"/>
    </bean>
​
</beans>

4. IOC創建對象的方式

1. 使用無參構造創建對象，默認。

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
​
    <bean id="user" class="com.hou.pojo.User">
        <constructor-arg index="0" value="hou"/>
    </bean>
</beans>

類型賦值（不建議使用）

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

直接通過參數名

<bean id="user" class="com.hou.pojo.User">
    <constructor-arg name="name" value="hou"></constructor-arg>
</bean>

Spring類似於婚介網站！

你想不想要，對象都在里面。注冊bean之后用不用被實例化。

5. Spring配置

別名

<bean id="user" class="com.hou.pojo.User">
    <constructor-arg name="name" value="hou"></constructor-arg>
</bean>
​
<alias name="user" alias="user2aaa"/>

Bean的配置

• id：bean的id標識符

• class：bean對象所對應的類型

• name：別名，更高級，可以同時取多個別名。

import

一般用於團隊開發，它可以將多個配置文件，導入合並為一個

<import resource="beans.xml"/>

6. DI依賴注入

構造器注入

set方式注入（重點）

• 依賴：bean對象的創建依賴於容器

• 注入：bean對象中的所有屬性，由容器來注入

【環境搭建】

1. 復雜類型

2. 真實測試對象

package com.pojo;
​
import java.util.*;
​
public class Student {
​
    private String name;
    private Address address;
​
    private String[] books;
    private List<String> hobbies;
​
    private Map<String, String> card;
    private Set<String> game;
​
    private Properties infor;
    private String wife;
​
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address +
                ", books=" + Arrays.toString(books) +
                ", hobbies=" + hobbies +
                ", card=" + card +
                ", game=" + game +
                ", infor=" + infor +
                ", wife='" + wife + '\'' +
                '}';
   }
}
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 + '\'' +
                '}';
   }
}
<?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.pojo.Address">
        <property name="address" value="xian"></property>
    </bean>
​
    <bean id="student" class="com.pojo.Student">
        <property name="name" value="hou"/>
        <property name="address" ref="address"/>
​
        <!--數組注入-->
        <property name="books">
            <array>
                <value>三國</value>
                <value>西游</value>
                <value>水滸</value>
            </array>
        </property>
​
        <!--list-->
        <property name="hobbies">
            <list>
                <value>eat</value>
                <value>drink</value>
                <value>play</value>
            </list>
        </property>
​
        <property name="card">
            <map>
                <entry key="1" value="12"/>
                <entry key="2" value="23"/>
            </map>
        </property>
​
        <property name="game">
            <set>
                <value>wangzhe</value>
                <value>daota</value>
                <value>lol</value>
            </set>
        </property>
​
        <property name="wife">
            <null></null>
        </property>
​
        <!--properties-->
        <property name="infor">
            <props>
                <prop key="id">20200405</prop>
                <prop key="name">hdk</prop>
            </props>
        </property>
    </bean>
​
</beans>

第三方

p標簽和c標簽

package com.pojo;
​
public class User {
​
    private String name;
    private int age;
​
    public User() {
   }
​
    public User(String name, int age) {
        this.name = name;
        this.age = age;
   }
​
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
   }
​
    public String getName() {
        return name;
   }
​
    public void setName(String name) {
        this.name = name;
   }
​
    public int getAge() {
        return age;
   }
​
    public void setAge(int age) {
        this.age = age;
   }
}
<?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命名空間注入/set注入-->
    <bean id="use" class="com.pojo.User" p:name="dong" p:age="10">
    </bean>
​
    <!--c命名空間/構造器-->
    <bean id="use2" class="com.pojo.User" c:name="kun" c:age="19"></bean>
</beans>

bean的作用域

 

1. 單例模式（默認）

<bean id="use2" class="com.pojo.User" c:name="kun" c:age="19" scope="singleton"></bean>

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

<bean id="use2" class="com.pojo.User" c:name="kun" c:age="19" scope="prototype"></bean>

1. 其余的request、session、application這些只能在web開放中使用！

7. Bean的自動裝配

• 自動裝配是Spring是滿足bean依賴的一種方式

• Spring會在上下文自動尋找，並自動給bean裝配屬性

在Spring中有三種裝配的方式

1. 在xml中顯示配置

2. 在java中顯示配置

3. 隱式的自動裝配bean 【重要】

4. 環境搭建：一個人有兩個寵物

5. Byname自動裝配：byname會自動查找，和自己對象set對應的值對應的id

   保證所有id唯一，並且和set注入的值一致

6. Bytype自動裝配：byType會自動查找，和自己對象屬性相同的bean

   保證所有的class唯一

public class Cat {
    public void jiao(){
        System.out.println("miao");
   }
}
public class Dog {
​
    public void jiao(){
        System.out.println("wow");
   }
​
}
package com.pojo;
​
​
public class People {
​
    private Cat cat;
    private Dog dog;
    private String name;
​
    @Override
    public String toString() {
        return "People{" +
                "cat=" + cat +
                ", dog=" + dog +
                ", name='" + name + '\'' +
                '}';
   }
​
    public Cat getCat() {
        return cat;
   }
​
    public void setCat(Cat cat) {
        this.cat = cat;
   }
​
    public Dog getDog() {
        return dog;
   }
​
    public void setDog(Dog dog) {
        this.dog = dog;
   }
​
    public String getName() {
        return name;
   }
​
    public void setName(String name) {
        this.name = name;
   }
}
<?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="cat11" class="com.pojo.Cat"/>
    <bean id="dog" class="com.pojo.Dog"/>
    <!--byname會自動查找，和自己對象set對應的值對應的id-->
    <!--<bean id="people" class="com.pojo.People" autowire="byName">-->
        <!--<property name="name" value="hou"></property>-->
    <!--</bean>-->
    <!--byType會自動查找，和自己對象屬性相同的bean-->
    <bean id="people" class="com.pojo.People" autowire="byType">
        <property name="name" value="hou"></property>
    </bean>
​
</beans>

使用注解自動裝配

jdk1.5支持的注解，spring2.5支持的注解

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

導入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>

@Autowire

在屬性上個使用，也可以在set上使用

我們可以不用編寫set方法了

public class People {
    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;
    private String name;
}
@Nullable 字段標志的注解，說明這個字段可以為null

如果@Autowired自動裝配環境比較復雜。自動裝配無法通過一個注解完成的時候

我們可以使用@Qualifier(value = "dog")去配合使用，指定一個唯一的id對象

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

@Resource(name="dog")也可以

區別：

• @autowire通過byType實現，而且必須要求這個對象存在

• @resource默認通過byName實現，如果找不到，通過byType實現

8. 使用注解開發

在spring4之后，必須要保證aop的包導入

使用注解需要導入contex的約束

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

1. 屬性如何注入

@Component
public class User {
    
    @Value("dong")
    private String name;
​
    public String getName() {
        return name;
   }
​
    public void setName(String name) {
        this.name = name;
   }
}

1. 衍生的注解

@Component有幾個衍生注解，會按照web開發中，mvc架構中分層。

• dao （@Repository）

• service（@Service）

• controller（@Controller）

這四個注解功能一樣的，都是代表將某個類注冊到容器中

1. 作用域

@Scope("singleton")

@Component
@Scope("prototype")
public class User {
​
    @Value("dong")
    private String name;
​
    public String getName() {
        return name;
   }
​
    public void setName(String name) {
        this.name = name;
   }
}

小結：

xml與注解

• xml更加萬能，維護簡單

• 注解，不是自己的類，使用不了，維護復雜

最佳實踐：

• xml用來管理bean

• 注解只用來完成屬性的注入

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
​
    <context:annotation-config/>
    <!--指定要掃描的包-->
    <context:component-scan base-package="com.pojo"/>
​
</beans>

9. 使用java方式配置spring

JavaConfig

Spring的一個子項目，在spring4之后，，他成為了核心功能

@Configuration //這個也會被spring容器托管，注冊到容器中，因為他本來就是一個@Component
@ComponentScan("com.pojo")
@Import(Config2.class)
public class MyConfig {
​
    @Bean
    public User getUser(){
        return new User();
   }
​
}
@Component
public class User {
​
    @Value("dong")
    private String name;
​
    public String getName() {
        return name;
   }
​
    public void setName(String name) {
        this.name = name;
   }
​
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
   }
}

這種純java配置方式

在springboot中，隨處可見

10. 動態代理

動態代理和靜態代理

角色一樣

動態代理類是動態生成的，不是我們直接寫好的！

動態代理：基於接口，基於類

• 基於接口：JDK的動態代理【使用】

• 基於類：cglib

• java字節碼

InvocationHandler

Proxy

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
​
//會這個類，自動生成代理類
public class ProxyInvocation 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);
   }
​
    //處理代理實例，並返回結果
    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("see house");
   }
​
    public void fare(){
        System.out.println("fare");
   }
}
public interface Rent {
    void rent();
}
public class Host implements Rent {
    public void rent() {
        System.out.println("host rent");
   }
}
public class Client {
​
    public static void main(String[] args) {
        //真實角色
        Host host = new Host();
​
        //代理角色
        ProxyInvocation proxyInvocation = new ProxyInvocation();
​
        //通過調用程序處理角色來處理我們要調用的接口對象
        proxyInvocation.setRent(host);
​
        Rent proxy = (Rent) proxyInvocation.getProxy();  //這里的proxy是動態生成的
​
        proxy.rent();
   }
}

11.AOP

<dependencies>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
    </dependency>
</dependencies>

方法一：使用spring接口【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/beanss
        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.service.UserServiceImp"></bean>
    <bean id="log" class="com.log.Log"/>
    <bean id="afterlog" class="com.log.AfterLog"/>
​
    <!--配置aop-->
    <aop:config>
        <!--切入點：expression:表達式，execution（要執行的位置）-->
        <aop:pointcut id="point" expression="execution(* com.service.UserServiceImp.*(..))"/>
        <!--執行環繞-->
        <aop:advisor advice-ref="log" pointcut-ref="point"/>
        <aop:advisor advice-ref="afterlog" pointcut-ref="point"/>
    </aop:config>
​
</beans>
public class UserServiceImp implements UserService {
​
​
   public void add() {
       System.out.println("add");
   }
​
   public void delete() {
       System.out.println("delete");
   }
​
   public void query() {
       System.out.println("query");
   }
​
   public void update() {
       System.out.println("update");
   }
}
import org.springframework.aop.MethodBeforeAdvice;
​
import java.lang.reflect.Method;
​
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());
   }
}
public class AfterLog implements AfterReturningAdvice {
​
   //returnVaule: 返回值
   public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
       System.out.println(method.getName()+returnValue);
   }
}
public class Mytest {
   public static void main(String[] args) {
       ApplicationContext context = new ClassPathXmlApplicationContext("ApplcationContext.xml");
       //動態代理代理的是接口
       UserService userService = (UserService) context.getBean("userservice");
       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.service.UserServiceImp"></bean>
    <bean id="log" class="com.log.Log"/>
    <bean id="afterlog" class="com.log.AfterLog"/>
​
    <bean id="diy" class="com.diy.DiyPointcut">
    </bean>
    <aop:config>
        <!--自定義切面-->
        <aop:aspect ref="diy">
            <!--切入點-->
            <aop:pointcut id="point" expression="execution(* com.service.UserServiceImp.*(..))"/>
            <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("before");
   }
​
   public void after(){
       System.out.println("after");
   }
}

方法三：注解方式

<?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 id="ann" class="com.diy.Annotation"></bean>
    <aop:aspectj-autoproxy/>
    <!--注冊bean-->
    <bean id="userservice" class="com.service.UserServiceImp"></bean>
    
</beans>
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
​
@Aspect //標注這個類是一個切面
public class Annotation {
​
   @Before("execution(* com.service.UserServiceImp.*(..))")
   public void before(){
       System.out.println("before");
   }
​
   @After("execution(* com.service.UserServiceImp.*(..))")
   public void after(){
       System.out.println("after");
   }
​
   //在環繞增強中，我們可以給地暖管一個參數，代表我們要獲取切入的點
   @Around("execution(* com.service.UserServiceImp.*(..))")
   public void around(ProceedingJoinPoint joinPoint) throws Throwable {
       System.out.println("around");
​
       Object proceed = joinPoint.proceed();
​
       System.out.println("after around");
   }
}

12. 整合mybatis

文檔： https://mybatis.org/spring/zh/

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>spring-study</artifactId>
        <groupId>com.hou</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
​
    <artifactId>spring-10-mybatis</artifactId>
​
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
​
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.4</version>
        </dependency>
​
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>
​
​
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
​
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
​
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
    </dependencies>
​
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>
​
</project>
<?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.pojo"/>
    </typeAliases>
​
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://111.230.212.103:3306/mybatis?userSSL=true&amp;
                userUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="hdk123"/>
            </dataSource>
        </environment>
    </environments>
​
    <mappers>
        <mapper class="com.mapper.UserMapper"/>
    </mappers>
</configuration>
<?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.mapper.UserMapper">
​
    <select id="selectUser" resultType="user">
       select * from mybatis.user;
    </select>
​
</mapper>
public interface UserMapper {
   List<User> selectUser();
}

整合

方法一：

 

UserMapperImpl

package com.mapper;
​
import com.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;
​
import java.util.List;
​
public class UserMapperImpl implements UserMapper {
​
    private SqlSessionTemplate sqlSessionTemplate;
​
    public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSessionTemplate = sqlSessionTemplate;
   }
​
    public List<User> selectUser() {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUser();
   }
}

mybatis.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.pojo"/>
    </typeAliases>
​
</configuration>

spring.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">
​
    <!--data source-->
    <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://111.230.212.103:3306/mybatis?userSSL=true&amp;
                userUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="hdk123"/>
    </bean>
​
    <!--sqlsession-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="datasource" />
        <!--bound mybatis-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/mapper/UserMapper.xml"/>
    </bean>
​
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
​
    <bean id="userMapper" class="com.mapper.UserMapperImpl">
        <property name="sqlSessionTemplate" ref="sqlSession"></property>
    </bean>
​
</beans>

test

import com.mapper.UserMapper;
import com.pojo.User;
import org.springframework.context.support.ClassPathXmlApplicationContext;
​
import java.io.IOException;
​
​
public class Mytest {
​
​
    public static void main(String[] args) throws IOException {
​
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
​
    <!--data source-->
    <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://111.230.212.103:3306/mybatis?userSSL=true&amp;
                userUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="hdk123"/>
    </bean>
​
    <!--sqlsession-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="datasource" />
        <!--bound mybatis-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/mapper/UserMapper.xml"/>
    </bean>
​
    <!--<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">-->
        <!--<constructor-arg index="0" ref="sqlSessionFactory"/>-->
    <!--</bean>-->
​
    <!--<bean id="userMapper" class="com.mapper.UserMapperImpl">-->
        <!--<property name="sqlSessionTemplate" ref="sqlSession"></property>-->
    <!--</bean>-->
​
    <bean id="userMapper2" class="com.mapper.UserMapperIml2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
    </bean>
​
</beans>
package com.mapper;
​
import com.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.support.SqlSessionDaoSupport;
​
import java.util.List;
​
public class UserMapperIml2 extends SqlSessionDaoSupport implements UserMapper {
   public List<User> selectUser() {
       SqlSession sqlSession = getSqlSession();
       UserMapper mapper = sqlSession.getMapper(UserMapper.class);
       return mapper.selectUser();
   }
}

13. 聲明式事務

• 要么都成功，要么都失敗

• 十分重要，涉及到數據一致性

• 確保完整性和一致性

事務的acid原則：

• 原子性

• 一致性

• 隔離性

  • 多個業務可能操作一個資源，防止數據損壞

• 持久性

  • 事務一旦提交，無論系統發生什么問題，結果都不會被影響。

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: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-tx.aop">
​
    <!--data source-->
    <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://111.230.212.103:3306/mybatis?userSSL=true&amp;
                userUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="hdk123"/>
    </bean>
​
    <!--sqlsession-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="datasource" />
        <!--bound mybatis-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/mapper/*.xml"/>
    </bean>
​
    <!--聲明式事務-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <constructor-arg ref="datasource" />
    </bean>
​
    <!--結合aop實現事務置入-->
    <!--配置事務的類-->
    <tx:advice id="tx1" 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="*" propagation="REQUIRED"/>
            <tx:method name="query" read-only="true"/>
        </tx:attributes>
    </tx:advice>
​
    <!--配置事務切入-->
    <aop:config>
        <aop:pointcut id="txpointxut" expression="execution(* com.mapper.*.*(..))"/>
        <aop:advisor advice-ref="tx1" pointcut-ref="txpointxut"/>
    </aop:config>
​
</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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
​
    <import resource="spring-dao.xml"/>
​
    <bean id="userMapper2" class="com.mapper.UserMapperIml2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
    </bean>
​
</beans>

Mapper

package com.mapper;
​
import com.pojo.User;
​
import java.util.List;
​
public interface UserMapper {
    List<User> selectUser();
    int addUser(User user);
    int delete(int id);
}
<?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.mapper.UserMapper">
    <select id="selectUser" resultType="user">
        select * from mybatis.user;
    </select>
​
    <insert id="addUser" parameterType="user">
        insert into mybatis.user (id, name, pwd) values
       (#{id}, #{name}, #{pwd})
    </insert>
​
    <delete id="delete" parameterType="int">
        delete from mybatis.user where id=#{id}
    </delete>
</mapper>
package com.mapper;
​
import com.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.support.SqlSessionDaoSupport;
​
import java.util.List;
​
public class UserMapperIml2 extends SqlSessionDaoSupport implements UserMapper {
​
    public List<User> selectUser() {
        User user = new User(6, "long", "zhi");
        SqlSession sqlSession = getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.addUser(user);
        mapper.delete(6);
        return mapper.selectUser();
   }
​
    public int addUser(User user) {
        return getSqlSession().getMapper(UserMapper.class).addUser(user);
   }
​
    public int delete(int id) {
        return getSqlSession().getMapper(UserMapper.class).delete(id);
   }
}