Spring

1、Spring

图片

1.1、简介

spring官网: 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: spring-webmvc最新版

1.2、优点

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

开源免费容器,轻量级非侵入式,控制反转,面向切面,支持事务,支持框架整合

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

1.3、组成

图片

Spring 框架是一个分层架构,由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上,核心容器定义了创建、配置和管理 bean 的方式 .

图片

组成 Spring 框架的每个模块(或组件)都可以单独存在,或者与其他一个或多个模块联合实现。每个模块的功能如下:

  • 核心容器:核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory,它是工厂模式的实现。BeanFactory 使用控制反转(IOC) 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
  • Spring 上下文:Spring 上下文是一个配置文件,向 Spring 框架提供上下文信息。Spring 上下文包括企业服务,例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
  • Spring AOP:通过配置管理特性,Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。所以,可以很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP,不用依赖组件,就可以将声明性事务管理集成到应用程序中。
  • Spring DAO:JDBC DAO 抽象层提供了有意义的异常层次结构,可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理,并且极大地降低了需要编写的异常代码数量(例如打开和关闭连接)。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
  • Spring ORM:Spring 框架插入了若干个 ORM 框架,从而提供了 ORM 的对象关系工具,其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
  • Spring Web 模块:Web 上下文模块建立在应用程序上下文模块之上,为基于 Web 的应用程序提供了上下文。所以,Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
  • Spring MVC 框架:MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口,MVC 框架变成为高度可配置的,MVC 容纳了大量视图技术,其中包括 JSP、Velocity、Tiles、iText 和 POI。

1.4、扩展

Spring Boot与Spring Cloud

  • Spring Boot 是 Spring 的一套快速配置脚手架,可以基于Spring Boot 快速开发单个微服务;
  • Spring Cloud是基于Spring Boot实现的;
  • Spring Boot专注于快速、方便集成的单个微服务个体,Spring Cloud关注全局的服务治理框架;
  • Spring Boot使用了约束优于配置的理念,很多集成方案已经帮你选择好了,能不配置就不配置 , Spring Cloud很大的一部分是基于Spring Boot来实现,Spring Boot可以离开Spring Cloud独立使用开发项目,但是Spring Cloud离不开Spring Boot,属于依赖的关系。
  • SpringBoot在SpringClound中起到了承上启下的作用,如果你要学习SpringCloud必须要学习SpringBoot。

图片

2、IOC理论推导

  1. UserDao 接口

    public interface UserDao {
       public void getUser();
    }
    
  2. UserDaoImpl 实现类

    public class UserDaoImpl implements UserDao {
       @Override
       public void getUser() {
           System.out.println("获取用户数据");
      }
    }
    
  3. UserService 业务接口

    public interface UserService {
       public void getUser();
    }
    
  4. UserServiceImpl 业务实现类

    public class UserServiceImpl implements UserService {
       private UserDao userDao = new UserDaoImpl();
    
       @Override
       public void getUser() {
           userDao.getUser();
      }
    }
    
  5. 测试一下

    @Test
    public void test(){
       UserService service = new UserServiceImpl();
       service.getUser();
    }
    

把Userdao的实现类增加一个 .

public class UserDaoMySqlImpl implements UserDao {
   @Override
   public void getUser() {
       System.out.println("MySql获取用户数据");
  }
}

紧接着我们要去使用MySql的话 , 我们就需要去service实现类里面修改对应的实现

public class UserServiceImpl implements UserService {
   private UserDao userDao = new UserDaoMySqlImpl();

   @Override
   public void getUser() {
       userDao.getUser();
  }
}

代码量十分大,修改一次的成本十分昂贵!

我们使用一个Set接口实现,已经发生了革命性的变化!

public class UserServiceImpl implements UserService {
   private UserDao userDao;
	// 利用set实现
   public void setUserDao(UserDao userDao) {
       this.userDao = userDao;
  }

   @Override
   public void getUser() {
       userDao.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包

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

pojo的Hello.java

package 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 "Holle [str=" + str + "]";
	}
}

在resource里面的xml配置

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


    <!--在Spring中创建对象,在Spring这些都称为bean
    	类型 变量名 = new 类型();
    	Holle holle = new Holle();
    	
    	bean = 对象(holle)
    	id = 变量名(holle)
    	class = new的对象(new Holle();)
    	property 相当于给对象中的属性设值,让str="Spring"
    -->
    
    <bean id="hello" class="pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>
</beans>

测试类MyTest

package holle1;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import pojo.Hello;

public class MyTest {

	public static void main(String[] args) {
		//获取Spring的上下文对象
		ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
		//我们的对象下能在都在spring·中管理了,我们要使用,直接取出来就可以了
		Hello holle = (Hello) context.getBean("hello");
		System.out.println(holle.toString());
	}

}

⭐️核心用set注入,所以必须要有下面的set()方法

//Hello类
public void setStr(String str) {
		this.str = str;
	}

⭐️思考:

image-20200801165156259
IOC:对象由Spring 来创建,管理,装配!

4、IOC创建对象的方式

  1. 使用无参构造创建对象,默认。

    package com.kuang.pojo;public class User { 
        private String name;
        public String getName() { 
            return name; 
        } 
        public void setName(String name) {
            this.name = name; 
        }
        @Override
        public String toString() {
            return "User{" +                "name='" + name + '\'' +                '}'; 
        }
        public void show(){
            System.out.println(name); 
        }}
    
    <bean id="user" class="com.kuang.pojo.User">
        <property name="name" value="张三"></property>
    </bean>
    
  2. 使用有参构造(如下)

下标赋值

index指的是有参构造中参数的下标,下标从0开始;

package com.kuang.pojo;

import lombok.ToString;
@ToString
public class User {
    private  String name;
    public User(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="user" class="com.kuang.pojo.User">
       <constructor-arg index="0" value="狂神" />
    </bean>
    
</beans>
public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
        User user=(User) context.getBean("user");
        System.out.println(user);
    }
}

类型赋值(不建议使用)

<!--第二种通过类型来赋值,不建议使用-->
    <bean id="user" class="com.kuang.pojo.User">
        <constructor-arg type="java.lang.String" value="aaaaa"></constructor-arg>
    </bean>

直接通过参数名(掌握)

<!--    第三种通过参数名-->
    <bean id="user" class="com.kuang.pojo.User">
        <constructor-arg name="name" value="bbbbb"></constructor-arg>
    </bean>
<!-- 比如参数名是name,则有name="具体值" -->

注册bean之后就对象的初始化了(类似 new 类名()

弹幕评论:

name方式还需要无参构造和set方法,index和type只需要有参构造

就算是new 两个对象,也是只有一个实例(单例模式:全局唯一

User user = (User) context.getBean("user");
User user2 = (User) context.getBean("user");
system.out.println(user == user2)//结果为true
123

总结:在配置文件加载的时候,容器(< bean>)中管理的对象就已经初始化了

5、Spring配置

5.1、别名

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

<alias name="user" alias="userLove"/>
<!-- 使用时
	User user2 = (User) context.getBean("userLove");	
-->

5.2、Bean的配置(name也可以当别名)

<!--id:bean的唯一标识符,也就是相当于我们学的对象名
class:bean对象所对应的会限定名:包名+类型
name:也是别名,而且name可以同时取多个别名 
空格 "," ";" 都是分隔符-->
<bean id="user" class="pojo.User" name="u1 u2,u3;u4">
    <property name="name" value="chen"/>
</bean>
<!-- 使用时
	User user2 = (User) context.getBean("u1");	
-->

5.3、import

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

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

  • 张三(beans.xm1)

  • 李四(beans2.xm1)

  • 王五(beans3.xm1)

  • applicationContext.xml

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

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

弹幕评论:

按照在总的xml中的导入顺序来进行创建,后导入的会重写先导入的,最终实例化的对象会是后导入xml中的那个

6、依赖注入(DI)

6.1、构造器注入

第4点有提到

6.2、set方式注入【重点】

依赖注入:set注入!

  • 依赖:bean对象的创建依赖于容器

  • 注入:bean对象中的所有属性,由容器来注入

    【环境搭建】

    1. 复杂类型

      Address类

    2. 真实测试对象

      Student类

    3. beans.xml

    4. 测试

      MyTest3

    Student类

package com.kuang.pojo;

import lombok.Data;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import java.util.*;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
@Setter
@Getter
public class Student {//别忘了写get和set方法(用lombok注解也行)
    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{" +"\n"+
                "name='" + name + '\'' +"\n"+
                ", address=" + address.toString() +"\n"+
                ", books=" + Arrays.toString(books) +"\n"+
                ", hobbies=" + hobbies +"\n"+
                ", card=" + card +"\n"+
                ", game=" + game +"\n"+
                ", infor=" + infor +"\n"+
                ", wife='" + wife + '\'' +"\n"+
                '}';
    }
}

12345678910111213141516171819202122232425262728293031323334353637383940

Address类

package com.kuang.pojo;

public class Address {

    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "Address{" +
                "address='" + address + '\'' +
                '}';
    }
}

123456789101112131415161718192021

beans.xml

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

    <bean id="address" class="com.kuang.pojo.Address">
        <property name="address" value="山东"></property>
    </bean>

    <bean id="student" class="com.kuang.pojo.Student">
<!--        第一种普通值注入-->
        <property name="name" value="张三"></property>
<!--        第二种外类注入-->
        <property name="address" ref="address"></property>
<!--        第三种数组注入-->
        <property name="book">
            <array>
                <value>三国演义</value>
                <value>三国演义1</value>
                <value>三国演义2</value>
                <value>三国演义3</value>
            </array>
        </property>
<!--        第四种map类型注入-->
        <property name="card">
            <map>
                <entry key="aaaa" value="aaaaaaaaaaa"></entry>
                <entry key="bbbb" value="bbbbbbbbbbb"></entry>
                <entry key="cccc" value="ccccccccccc"></entry>
            </map>
        </property>
<!--        第五种set注入-->
        <property name="games">
            <set>
                <value>aaa</value>
                <value>bbb</value>
            </set>
        </property>
<!--        第六种list注入-->
        <property name="hobbys">
            <list>
                <value>a</value>
                <value>b</value>
                <value>c</value>
                <value>d</value>
            </list>
        </property>
<!--        第七种null注入-->
        <property name="wife">
            <null></null>
        </property>
<!--        第七种其他类型注入-->
        <property name="info">
            <props>
                <prop key="学号">201703070037</prop>
            </props>
        </property>
    </bean>


</beans>

MyTest

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

6.3、拓展注入

(p命名空间注入实质是set注入)

c命名空间,通过构造器注入

pojo增加User类

package pojo;

public class User {
    private String name;
    private int id;
	public User() {
        
	}
	public User(String name, int id) {
		super();
		this.name = name;
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	@Override
	public String toString() {
		return "User [name=" + name + ", id=" + id + "]";
	}
}
123456789101112131415161718192021222324252627282930

注意: beans 里面加上这下面两行

使用p和c命名空间需要导入xml约束

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

UserBean.xml

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

    <!--p命名空间注入/set注入,可以直接注入属性的值-》property-->
    <bean id="user" class="com.kuang.pojo.User" p:name="cxk" p:id="20" >
    </bean>

    <!--c命名空间,通过构造器注入,需要写入有参和无参构造方法-》construct-args-->
    <bean id="user2" class="com.kuang.pojo.User" c:name="cbh" c:id="22"></bean>
</beans>
123456789101112131415

测试

public void test01(){
        ApplicationContext context = new ClassPathXmlApplicationContext("UserBean.xml");
        User user = context.getBean("user",User.class);//确定class对象,就不用再强转了
        System.out.println(user.toString());
    }

6.4、Bean作用域

image-20200802143401165

image-20200802143342586

  1. 单例模式(默认)

    <bean id="user2" class="pojo.User" c:name="cxk" c:age="19" scope="singleton"></bean>
    1
    

image-20200802143802005
弹幕评论:单例模式是把对象放在pool中,需要再取出来,使用的都是同一个对象实例

  1. 原型模式: 每次从容器中get的时候,都产生一个新对象!

    <bean id="user2" class="pojo.User" c:name="cxk" c:age="19" scope="prototype"></bean>
    1
    12
    

image-20200802143826227

  1. 其余的request、session、application这些只能在web开放中使用!

7、Bean的自动装配

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

在Spring中有三种装配的方式

  1. 在xml中显示配置

  2. 在java中显示配置

  3. 隐式的自动装配bean 【重要】

  4. 环境搭建:一个人有两个宠物

  5. byType自动装配:byType会自动查找,和自己对象set方法参数的类型相同的bean

    保证所有的class唯一(类为全局唯一)

  6. byName自动装配:byName会自动查找,和自己对象set对应的值对应的id

    保证所有id唯一,并且和set注入的值一致

<!-- 找不到id和多个相同class -->
<bean id="cat1" class="pojo.Cat"/>
<bean id="cat2" class="pojo.Cat"/>
找不到 id=cat,且有两个Cat
1234

7.1测试:自动装配

pojo的Cat类

public class Cat {
    public void shut(){
        System.out.println("miao");
    }
}
12345
123456

pojo的Dog类

public class Dog {

    public void shut(){
        System.out.println("wow");
    }

}
1234567

pojo的People类

public class People {
    
    private Cat cat;
    private Dog dog;
    private String 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;
    }
    @Override
    public String toString() {
        return "People{" +
                "cat=" + cat +
                ", dog=" + dog +
                ", name='" + name + '\'' +
                '}';
    }
}
1234567891011121314151617181920212223242526272829303132333435363738

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="dog" class="com.kuang.pojo.Dog"/>
    <bean id="cat" class="com.kuang.pojo.Cat"/>

    <bean id="people" class="com.kuang.pojo.People">
        <property name="name" value="狂神"/>
        <property name="cat" ref="cat"/>
        <property name="dog" ref="dog"/>
    </bean>
</beans>
1234567891011121314

测试:

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
        People p=context.getBean("people",People.class);
        p.getCat().shut();
        p.getDog().shut();
	System.out.println( p.getName());
    }
}
123456789

xml配置 -> byType 自动装配(-byType会在容器自动查找,和自己对象属性相同的bean例如,Dog dog; 那么就会查找pojo的Dog类,再进行自动装配)

<?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="dog" class="com.kuang.pojo.Dog"/>
    <bean id="cat" class="com.kuang.pojo.Cat"/>
    
    <!--byType会在容器自动查找,和自己对象属性相同的bean
		例如,Dog dog; 那么就会查找pojo的Dog类,再进行自动装配
	-->
    <bean id="people" class="pojo.People" autowire="byType">
        <property name="name" value="cbh"></property>
    </bean>

</beans>
1234567891011121314151617

xml配置 -> byName 自动装配(byname会在容器自动查找,和自己对象set方法的set后面的值对应的id
例如:setDog(),取set后面的字符作为id,则要id = dog 才可以进行自动装配)

 <bean id="dog" class="com.kuang.pojo.Dog"/>
  <bean id="cat" class="com.kuang.pojo.Cat"/>
<!--byname会在容器自动查找,和自己对象set方法的set后面的值对应的id
  例如:setDog(),取set后面的字符作为id,则要id = dog 才可以进行自动装配
  
 -->
  <bean id="people2" class="com.kuang.pojo.People" autowire="byName">
        <property name="name" value="人类"/>
   </bean>
123456789

弹幕评论:byName只能取到小写,大写取不到

7.2.2、@Autowired+@Qualifier

@Autowired不能唯一装配时,需要@Autowired+@Qualifier

如果@Autowired自动装配环境比较复杂。自动装配无法通过一个注解完成的时候,可以使用@Qualifier(value = “dog”)去配合使用,指定一个唯一的id对象

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

弹幕评论:

如果xml文件中同一个对象被多个bean使用,Autowired无法按类型找到,可以用@Qualifier指定id查找

7.2.3、@Resource

默认是byName方式,如果匹配不上,就会byType

public class People {
    Resource(name="cat")
    private Cat cat;
    Resource(name="dog")
    private Dog dog;
    private String name;
}
1234567

弹幕评论:

Autowired是byType,@Autowired+@Qualifier = byType || byName

Autowired是先byteType,如果唯一則注入,否则byName查找。resource是先byname,不符合再继续byType

区别:

@Resource和@Autowired的区别:

  • 都是用来自动装配的,都可以放在属性字段上
  • @Autowired通过byType的方式实现,而且必须要求这个对象存在!【常用】
  • @Resource默认通过byname的方式实现,如果找不到名字,则通过byType实现!如果两个都找不到的情况下,就报错!【常用】
  • 执行顺序不同:@Autowired通过byType的方式实现。@Resource默认通过byname的方式实现

8、使用注解开发

在spring4之后,使用注解开发,必须要保证aop包的导入
image-20200802201924490
使用注解需要导入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>
123456789101112
12345678910111213

8.1、bean

弹幕评论:
有了< context:component-scan>,另一个< context:annotation-config/>标签可以移除掉,因为已经被包含进去了。

<!--指定要扫描的包,这个包下面的注解才会生效
	别只扫一个com.kuang.pojo包--> 
<context:component-scan base-package="com.kuang"/> 
<context:annotation-config/>
1234
//@Component 组件
//等价于<bean id="user" classs"pojo.User"/> 
@Component
public class User {  
     public String name ="秦疆";
}
1234567891011

8.2、属性如何注入@value

@Component
public class User { 
    //相当于<property name="name" value="kuangshen"/> 
    @value("kuangshen") 
    public String name; 
    
    //也可以放在set方法上面
    //@value("kuangshen")
    public void setName(String name) { 
        this.name = name; 
    }
}
123456789101112

8.3、衍生的注解

@Component有几个衍生注解,会按照web开发中,mvc架构中分层。

  • dao (@Repository)
  • service(@Service)
  • controller(@Controller)

这四个注解的功能是一样的,都是代表将某个类注册到容器中

8.4、自动装配置

@Autowired:默认是byType方式,如果匹配不上,就会byName

@Nullable:字段标记了这个注解,说明该字段可以为空

@Resource:默认是byName方式,如果匹配不上,就会byType

8.5、作用域@scope

//原型模式prototype,单例模式singleton
//scope("prototype")相当于<bean scope="prototype"></bean>
@Component 
@scope("prototype")
public class User { 
    
    //相当于<property name="name" value="kuangshen"/> 
    @value("kuangshen") 
    public String name; 
    
    //也可以放在set方法上面
    @value("kuangshen")
    public void setName(String name) { 
        this.name = name; 
    }
}
12345678910111213141516

8.6、小结

xml与注解:

  • xml更加万能,维护简单,适用于任何场合
  • 注解,不是自己的类使用不了,维护复杂

最佳实践:

  • xml用来管理bean
  • 注解只用来完成属性的注入
  • 要开启注解支持

9、使用Java的方式配置Spring

不使用Spring的xml配置,完全交给java来做!

Spring的一个子项目,在spring4之后,,,它成为了核心功能

image-20200802215752868
实体类:pojo的User.java

//这里这个注解的意思,就是说明这个类被Spring接管了,注册到了容器中 
@component 
public class User { 
    private String name;
    
    public String getName() { 
    	return name; 
    } 
    //属性注入值
    @value("QINJIANG')  
    public void setName(String name) { 
    	this.name = name; 
    } 
    @Override 
    public String toString() { 
        return "user{" + 
        "name='" + name + '\''+ 
        '}'; 
    } 
}
1234567891011121314151617181920
123456789101112131415161718192021

弹幕评论:要么使用@Bean,要么使用@Component和ComponentScan,两种效果一样

配置文件:config中的kuang.java

@Import(KuangConfig2.class),用@import来包含KuangConfig2.java

//这个也会Spring容器托管,注册到容器中,因为他本米就是一个@Component 
// @Configuration表这是一个配置类,就像我们之前看的beans.xml,类似于<beans>标签
@Configuration 
@componentScan("com.Kuang.pojo") //开启扫描
//@Import(KuangConfig2.class)
public class KuangConfig { 
    //注册一个bean , 就相当于我们之前写的一个bean 标签 
    //这个方法的名字,就相当于bean 标签中的 id 属性 ->getUser
    //这个方法的返同值,就相当于bean 标签中的class 属性 ->User
    
    //@Bean 
    public User getUser(){ 
    	return new User(); //就是返回要注入到bean的对象! 
    } 
}
123456789101112131415
12345678910111213141516

弹幕评论:ComponentScan、@Component("pojo”) 这两个注解配合使用

测试类

public class MyTest { 
    public static void main(String[ ] args) { 
    //如果完全使用了配置类方式去做,我们就只能通过 Annotationconfig 上下文来获取容器,通过配置类的class对象加载! 
    ApplicationContext context = new AnnotationConfigApplicationContext(KuangConfig.Class); //class对象
    User getUser =(User)context.getBean( "getUser"); //方法名getUser
    System.out.Println(getUser.getName()); 
    } 
}
12345678
123456789

会创建两个相同对象问题的说明:

弹幕总结 - -> @Bean是相当于< bean>标签创建的对象,而我们之前学的@Component是通过spring自动创建的这个被注解声明的对象,所以这里相当于有两个User对象被创建了。一个是bean标签创建的(@Bean),一个是通过扫描然后使用@Component,spring自动创建的User对象,所以这里去掉@Bean这些东西,然后开启扫描。之后在User头上用@Component即可达到spring自动创建User对象了

//这个也会Spring容器托管,注册到容器中,因为他本米就是一个@Component 
// @Configuration表这是一个配置类,就像我们之前看的beans.xml,类似于<beans>标签
@Configuration 
@componentScan("com.Kuang.pojo") //开启扫描
//@Import(KuangConfig2.class)
public class KuangConfig { 
    //注册一个bean , 就相当于我们之前写的一个bean 标签 
    //这个方法的名字,就相当于bean 标签中的 id 属性 ->getUser
    //这个方法的返同值,就相当于bean 标签中的class 属性 ->User
    
    //@Bean 
    public User getUser(){ 
    	return new User(); //就是返回要注入到bean的对象! 
    } 
}
123456789101112131415
12345678910111213141516

弹幕评论:ComponentScan、@Component("pojo”) 这两个注解配合使用

测试类

public class MyTest { 
    public static void main(String[ ] args) { 
    //如果完全使用了配置类方式去做,我们就只能通过 Annotationconfig 上下文来获取容器,通过配置类的class对象加载! 
    ApplicationContext context = new AnnotationConfigApplicationContext(KuangConfig.Class); //class对象
    User getUser =(User)context.getBean( "getUser"); //方法名getUser
    System.out.Println(getUser.getName()); 
    } 
}
12345678
123456789

会创建两个相同对象问题的说明:

弹幕总结 - -> @Bean是相当于< bean>标签创建的对象,而我们之前学的@Component是通过spring自动创建的这个被注解声明的对象,所以这里相当于有两个User对象被创建了。一个是bean标签创建的(@Bean),一个是通过扫描然后使用@Component,spring自动创建的User对象,所以这里去掉@Bean这些东西,然后开启扫描。之后在User头上用@Component即可达到spring自动创建User对象了

10、代理模式

我的理解:代理模式就是在不改变原有代码的条件下,新建一个代理类,在这个类中进行功能的添加

代理模式是SpringAOP的底层

分类:动态代理和静态代理

image-20200803101427846

10.1、静态代理

image-20200803101621868
代码步骤:

1、接口

package pojo;
public interface Host {
	public void rent();
}
1234
12345

2、真实角色

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

3、代理角色

package pojo;
public class Proxy {

	public Host host;
	
	public Proxy() {
		
	}
	
	public Proxy(Host host) {
		super();
		this.host = host;
	}
	
	public void rent() {
		seeHouse();
		host.rent();
		fee();
		sign();
	}
	//看房
	public void seeHouse() {
		System.out.println("看房子");
	}
	//收费
	public void fee() {
		System.out.println("收中介费");
	}
	//合同
	public void sign() {
		System.out.println("签合同");
	}		
}

4、客户端访问代理角色

package holle4_proxy;

import pojo.Host;
import pojo.HostMaster;
import pojo.Proxy;

public class My {

	public static void main(String[] args) {
		//房东要出租房子
		Host host = new HostMaster();
		//中介帮房东出租房子,但也收取一定费用(增加一些房东不做的操作)
		Proxy proxy = new Proxy(host);
		//看不到房东,但通过代理,还是租到了房子
		proxy.rent();
		
	}
}

10.2、加深理解

image-20200803105229478
代码翻倍:几十个真实角色就得写几十个代理

AOP横向开发

image-20200803111539621

10.3、动态代理

  • 动态代理的角色和静态代理的一样 .

  • 动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的

  • 动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理

    • 基于接口的动态代理----JDK动态代理
    • 基于类的动态代理–cglib
    • 现在用的比较多的是 javasist 来生成动态代理 . 百度一下javasist
    • 我们这里使用JDK的原生代码来实现,其余的道理都是一样的!、

JDK的动态代理需要了解两个类

核心 : InvocationHandler 和 Proxy , 打开JDK帮助文档看看

【InvocationHandler:调用处理程序】

图片

Object invoke(Object proxy, 方法 method, Object[] args);//参数//proxy - 调用该方法的代理实例//method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口,它可以是代理类继承该方法的代理接口的超级接口。//args -包含的方法调用传递代理实例的参数值的对象的阵列,或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中,例如java.lang.Integer或java.lang.Boolean 。

【Proxy : 代理】

图片

图片

图片

//生成代理类
public Object getProxy(){
    return Proxy.newProxyInstance(this.getClass().getClassLoader(),                                 rent.getClass().getInterfaces(),this);
}

代码实现

抽象角色和真实角色和之前的一样!

RentHouse. java 即抽象角色

public interface RentHouse {
    void rent();
}

HouseMaster. java 即真实角色

public class HouseMaster implements RentHouse {
    public void rent() {
        System.out.println("出租!!!!!!!!!");
    }
}

ProxyInvocationHandler. java 即代理角色


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

    //执行方法
    //这里的形参prox,代表代理对象
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(target, args);
        return result;
    }
}

Clienter. java

public class Clienter {
    public static void main(String[] args) {
        //先定义真实对象
        HouseMaster houseMaster = new HouseMaster();
        //生成空白代理对象
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //将要代理的类传过去
        pih.setTarget(houseMaster);
        //得到代理对象
        RentHouse proxy = (RentHouse) pih.getProxy();
        proxy.rent();
    }
}

核心:一个动态代理 , 一般代理某一类业务 , 一个动态代理可以代理多个类,代理的是接口!、

动态代理的好处

静态代理有的它都有,静态代理没有的,它也有!

  • 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
  • 公共的业务由代理来完成 . 实现了业务的分工 ,
  • 公共业务发生扩展时变得更加集中和方便 .
  • 一个动态代理 , 一般代理某一类业务
  • 一个动态代理可以代理多个类,代理的是接口!

11、AOP

aop execution举例

执行(* com.sample.service.impl … *。*(…))

解释如下:

符号含义
执行()表达式的主体;
第一个” *“符号表示返回值的类型任意;
com.sample.service.implAOP所切的服务的包名,即,我们的业务部分
包名后面的” …“表示当前包及子包
第二个” *“表示类名,*即所有类。此处可以自定义,下文有举例
。*(…)表示任何方法名,括号表示参数,两个点表示任何参数类型

AspectJ中的exection表达式小结:

基本语法格式为:

执行(<修饰符模式>?<返回类型模式> <方法名模式>(<参数模式>)<异常模式>?)除了返回类型模式,方法名模式和参数模式外,其它项都是可选的。

1)通过方法签名定义切点

执行(公共* *(…))

匹配所有目标类的公共方法,但不匹配SmartSeller和protected voidshowGoods()方法。第一个代表返回类型,第二个代表方法名,而…代表任意入参的方法;

执行(* * To(…))l

匹配目标类所有以要为后缀的方法它匹配NaiveWaiter和NaughtyWaiter的greetTo()和serveTo()方法第一个代表返回类型,而为代表任意以要为后缀的方法。;

2)通过类定义切点

执行(* com.baobaotao.Waiter。*(…))升

匹配服务员接口的所有方法,它匹配NaiveWaiter和NaughtyWaiter类的greetTo()和serveTo()方法第一个*代表返回任意类型,com.baobaotao.Waiter *代表服务员接口中的所有方法。;

执行(* com.baobaotao.Waiter + *(…))升

匹配服务员接口及其所有实现类的方法,它不但匹配NaiveWaiter和NaughtyWaiter类的greetTo()和serveTo()这两个服务员接口定义的方法,同时还匹配NaiveWaiter#微笑()和NaughtyWaiter#笑话()这两个不在服务员接口中定义的方法。

3)通过类包定义切点

在类名模式串中,“*”表示包下的所有类,而“… *”表示包,子孙包下的所有类。

执行(* com.baobaotao。*(…))l

匹配com.baobaotao包下所有类的所有方法;

执行(* com.baobaotao … *(…))l

匹配com.baobaotao包,子孙包下所有类的所有方法,如com.baobaotao.dao,com.baobaotao.servier以及com.baobaotao.dao.user包下的所有类的所有方法都匹配。“”出现在类名中时,后面必须跟“*”,表示包,子孙包下的所有类;

执行(* com … Dao.find *(…))l

匹配包名前缀为COM的任何包下类名后缀为道的方法,方法名必须以发现为前缀。如com.baobaotao.UserDao#findByUserId(),com.baobaotao.dao.ForumDao#findById()的方法都匹配切点。

4)通过方法入参定义切点

切点表达式中方法入参部分比较复杂,可以使用“”和“…”通配符,其中“”表示任意类型的参数,而“…”表示任意类型参数且参数个数不限。

执行(* joke(String,int)))l

匹配joke(String,int)方法,且joke()方法的第一个入参是String,第二个参参是int。它匹配NaughtyWaiter #joke(String,int)方法。如果方法中的入参类型是java.lang中包下的类,可以直接使用类名,否则必须使用全限定类名,如笑话(java.util.List中,int);在

执行(* joke(String,*)))l

匹配目标类中的笑话()方法,该方法第一个入参为String,第二个参参可以是任意类型,如笑话(Strings1,String s2)和笑话(String s1,double d2)都匹配,但是笑话(String s1,doubled2,String s3)则不匹配;

执行(* joke(String,…)))l

匹配目标类中的笑话()方法,该方法第一个入参为String,后面可以有任意个入参和入参类型不限,如笑话(Strings1),笑话(String s1,String s2)和笑话( String s1,double d2,Strings3)都匹配。

执行(*笑话(对象+)))

匹配目标类中的笑话()方法,方法拥有一个入参,且入参是对象类型或该类的子类。它匹配笑话(Strings1)和笑话(客户c)。如果我们定义的切点是执行(* joke(Object)),则只匹配笑话(Object object)而不匹配笑话(Stringcc)或笑话(Client c)。

11.1、什么是AOP

image-20200803134502169

11.2、AOP在Spring中的使用

提供声明式事务,允许用户自定义切面

  • 横切关注点:跨越应用程序多个模块的方法或功能。即是,与我们业务逻辑无关的,但是我们需要关注的部分,就是横切关注点。如日志,安全,缓存,事务等等…
  • 切面(Aspect):横切关注点 被模块化的特殊对象。即,它是一个类。(Log类)
  • 通知(Advice):切面必须要完成的工作。即,它是类中的一个方法。(Log类中的方法)
  • 目标(Target):被通知对象。(生成的代理类)
  • 代理(Proxy):向目标对象应用通知之后创建的对象。(生成的代理类)
  • 切入点(PointCut):切面通知执行的”地点”的定义。(最后两点:在哪个地方执行,比如:method.invoke())
  • 连接点(JointPoint):与切入点匹配的执行点。

image-20200803154043909
SpringAOP中,通过Advice定义横切逻辑,Spring中支持5种类型的Advice:

image-20200803135937435
即AOP在不改变原有代码的情况下,去增加新的功能。(代理)

11.3、使用Spring实现AOP

导入jar包

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

11.3.1、方法一:使用原生spring接口

springAPI接口实现

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

    <!-- bean definition & AOP specific configuration -->

    <!--注册bean-->
    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
    <bean id="log" class="com.kuang.log.Log" />
    <bean id="afterlog" class="com.kuang.log.AfterLog" />
    <!--方式一,使用原生的spring API接口-->
    <!--注册aop-->
    <!--配置aop需要导入aop的约束-->

    <aop:config>
        <!--aop的切入点: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>
123456789101112131415161718192021222324252627

execution(返回类型,类名,方法名(参数)) -> execution(* com.service.,(…))

UserService.java

package com.kuang.service;

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

UserService 的实现类 UserServiceImp.java

package com.kuang.service;

public class UserServiceImpl implements UserService {

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

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

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

    public void select() {
        System.out.println("查询了一个用户");
    }
}
1234567891011121314151617181920

前置Log.java

package com.kuang.log;

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()+"被执行了");
    }
}
1234567891011121314

后置AfterLog.java

package com.kuang.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

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

测试类MyTest

import com.kuang.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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


    }
}
1234567891011121314

11.3.2、方法二:自定义类实现AOP

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

    <!-- bean definition & AOP specific configuration -->

    <!--注册bean-->
    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
    <bean id="log" class="com.kuang.log.Log" />
    <bean id="afterlog" class="com.kuang.log.AfterLog" />
    <!--方式一,使用原生的spring API接口-->
    <!--注册aop-->
    <!--配置aop需要导入aop的约束-->

    <!--<aop:config>
        &lt;!&ndash;aop的切入点: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.DIYPoint"/>
    <aop:config>
        <!--自定义切面,ref:要引用的类-->
        <aop:aspect ref="diy">
            <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>
1234567891011121314151617181920212223242526272829303132333435363738

DIYPoint.java

package com.kuang.diy;

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

1234567891011

11.3.3、方法三:使用注解实现

<?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="userservice" class="service.UserServiceImpl"/>
    <!--方式三,使用注解实现-->
    <bean id="diyAnnotation" class="diy.DiyAnnotation"></bean>
    
    <!-- 开启自动代理 
		实现方式:默认JDK (proxy-targer-class="fasle")
    			 cgbin (proxy-targer-class="true")-->
	<aop:aspectj-autoproxy/>
    
</beans>
1234567891011121314151617181920

DiyAnnotation.java

package com.kuang.diy;

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;

//使用注解aop
@Aspect //标注这个类是一个切面
public class AnnotationPointCut {
    @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("======方法执行前2=======");
    }
    @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("======方法执行后2=======");
    }
    //在环绕增强中,我们可以给地暖管一个参数,代表我们要获取切入的点
    @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void arrount(ProceedingJoinPoint jp) throws Throwable{
        System.out.println("环绕前");
        Object proceed = jp.proceed();
        System.out.println("环绕后");
    }
}


1234567891011121314151617181920212223242526272829

测试

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

输出结果:

image-20200803175642064

12、整合mybatis

自我总结步骤

1.导入依赖

2.建包建类,建完实体类去写接口

3.写配置文件

4.整合mybatis

  • 写入数据源
  • sqlsessionfactory
  • sqlsessiontemeplate
  • 再去写usermapper

5.最后写实现类

mybatis-spring官网:https://mybatis.org/spring/zh/

mybatis的配置流程:

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

12.1、mybatis-spring-方式一

  1. 编写数据源配置
  2. sqISessionFactory
  3. sqISessionTemplate(相当于sqISession)
  4. 需要给接口加实现类【new】
  5. 将自己写的实现类,注入到Spring中
  6. 测试!

先导入jar包

<dependencies>

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

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

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

    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>

    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.4</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.12</version>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
    </dependency>

</dependencies>
	
<!--在build中配置resources,来防止资源导出失败的问题-->
<!-- Maven解决静态资源过滤问题 -->
<build>
<resources>
    <resource>
        <directory>src/main/java</directory>
        <includes>
            <include>**/*.properties</include>
            <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
    </resource>
    <resource>
        <directory>src/main/resources</directory>
        <includes>
            <include>**/*.properties</include>
            <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
    </resource>
</resources>
</build>

文件路径
编写顺序:
User -> UserMapper -> UserMapper.xml -> spring-dao.xml -> UserServiceImpl -> applicationContext.xml -> MyTest6

代码步骤:

pojo实体类 User

package pojo;
import lombok.Data;
@Data
public class User {
	 private int id;
    private String name;
    private String pwd;
}
12345678

mapper目录下的 UserMapper、UserMapperImpl、UserMapper.xml

接口UserMapper

package mapper;
import java.util.List;
import pojo.User;
public interface UserMapper {
	public List<User> getUser();
}
123456

UserMapperImpl

package mapper;
import java.util.List;
import org.mybatis.spring.SqlSessionTemplate;
import pojo.User;

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

	public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
		this.sqlSessionTemplate = sqlSessionTemplate;
	}

	public List<User> getUser() {
		UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
		return mapper.getUser();
	}
}9
12345678910111213141516171819

UserMapper.xml (狂神给面子才留下来的)

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!--namespace=绑定一个指定的Dao/Mapper接口-->
<mapper namespace="com.kuang.mapper.UserMapper">
    <select id="getUserList" resultType="com.kuang.pojo.User">
    select * from mybatis.user
  </select>
</mapper>
1234567891011

resource目录下的 mybatis-config.xml、spring-dao.xml、applicationContext.xml

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核心配置文件-->
<configuration>

    <!-- 配置mybatis的log实现为STDOUT_LOGGING -->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

</configuration>

1234567891011121314

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
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
    <!--DataSource:使用Spring的数帮源替换Mybatis的配置 其他数据源:c3p0、dbcp、druid
		这使用Spring提供的JDBC: org.springframework.jdbc.datasource -->
    <!--data source -->
    <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf-8&amp;serverTimezone=Asia/Shanghai"/>
        <property name="username" value="root" />
        <property name="password" value="root" />
    </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>

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

        <!-- 导入spring-dao.xml -->
        <import resource="spring-dao.xml"/>

    <bean id="userMapper" class="com.kuang.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"></property>
    </bean>
</beans>

1234567891011121314151617

测试类

public class MyTest {
    @Test
    public void test01(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper=context.getBean("userMapper",UserMapper.class);
        for (User user:userMapper.getUserList()){
            System.out.println(user);
        }
    }
}
12345678910

12.2、mybatis-spring-方式二

UserServiceImpl2

package com.kuang.mapper;

import com.kuang.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import java.util.List;
import java.util.Map;

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {

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

    public void addUser2(Map<String, Object> map) {

    }

    public List<User> getUserLike(String value) {
        return null;
    }

    public List<User> getUserLimit(Map<String, Integer> map) {
        return null;
    }
}

123456789101112131415161718192021222324252627282930

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
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
    <!--DataSource:使用Spring的数帮源替换Mybatis的配置 其他数据源:c3p0、dbcp、druid
		这使用Spring提供的JDBC: org.springframework.jdbc.datasource -->
    <!--data source -->
    <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf-8&amp;serverTimezone=Asia/Shanghai"/>
        <property name="username" value="root" />
        <property name="password" value="root" />
    </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>
12345678910111213141516171819202122232425262728293031

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

        <!-- 导入spring-dao.xml -->
        <import resource="spring-dao.xml"/>

    <bean id="userMapper" class="com.kuang.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"></property>
    </bean>
    <bean id="userMapper2" class="com.kuang.mapper.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>
</beans>
12345678910111213141516171819

测试

public class MyTest {
    @Test
    public void test01(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper=context.getBean("userMapper2",UserMapper.class);
        for (User user:userMapper.getUserList()){
            System.out.println(user);
        }
    }
}
12345678910

13. 声明式事务

  • 把一组业务当成一个业务来做;要么都成功,要么都失败!
  • 事务在项目开发中,十分的重要,涉及到数据的一致性问题
  • 确保完整性和一致性

事务的ACID原则:
1、原子性
2、隔离性
3、一致性
4、持久性

ACID参考文章:https://www.cnblogs.com/malaikuangren/archive/2012/04/06/2434760.html

Spring中的事务管理

  • 声明式事务:AOP
  • 编程式事务:需要再代码中,进行事务管理

声明式事务

先导入jar包

<dependencies>

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

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

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

    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>

    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.4</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.12</version>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
    </dependency>

</dependencies>
	
<!--在build中配置resources,来防止资源导出失败的问题-->
<!-- Maven解决静态资源过滤问题 -->
<build>
<resources>
    <resource>
        <directory>src/main/java</directory>
        <includes>
            <include>**/*.properties</include>
            <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
    </resource>
    <resource>
        <directory>src/main/resources</directory>
        <includes>
            <include>**/*.properties</include>
            <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
    </resource>
</resources>
</build>
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970

代码步骤:

pojo实体类 User

@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private String pwd;
}
123456789

mapper目录下的 UserMapper、UserMapperImpl、UserMapper.xml

接口UserMapper

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

    public int insertUser(User user);

    public int delUser(@Param("id") int id);
}
1234567

UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!--namespace=绑定一个指定的Dao/Mapper接口-->

<!-- 绑定接口 -->
<mapper namespace="com.kuang.mapper.UserMapper">
    <select id="getUser" resultType="com.kuang.pojo.User">
		select * from user
	</select>

    <insert id="insertUser"  parameterType="com.kuang.pojo.User" >
		insert into mybatis.User (id,name,pwd) values (#{id},#{name},#{pwd})
	</insert>

    <delete id="delUser" parameterType="_int">
        delete AAAfrom mybatis.user where id = #{id}
        <!-- deleteAAAAA是故意写错的 -->
    </delete>

</mapper>
1234567891011121314151617181920212223

UserMapperImpl( extends SqlSessionDaoSupport)

public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {

    public List<User> getUser() {
        User user = new User(8,"你好","wwww");

        //insertUser(user);
        //delUser(7);
        SqlSession sqlSession = getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.insertUser(user);
        mapper.delUser(9);
        return mapper.getUser();
        //或者return  getSqlSession().getMapper(UserMapper.class).getUser();
    }
    //插入
    public int insertUser(User user) {
        return getSqlSession().getMapper(UserMapper.class).insertUser(user);
    }
    //删除
    public int delUser(int id) {
        return getSqlSession().getMapper(UserMapper.class).delUser(id);
    }
}

12345678910111213141516171819202122232425

resource目录下的 mybatis-config.xml、spring-dao.xml、applicationContext.xml

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核心配置文件-->
<configuration>

    <!-- 配置mybatis的log实现为STDOUT_LOGGING -->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

</configuration>

1234567891011121314

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"
       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/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--DataSource:使用Spring的数帮源替换Mybatis的配置 其他数据源:c3p0、dbcp、druid
		这使用Spring提供的JDBC: org.springframework.jdbc.datasource -->
    <!--data source -->
    <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf-8&amp;serverTimezone=Asia/Shanghai"/>
        <property name="username" value="root" />
        <property name="password" value="root" />
    </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>
    <!--配置声明式事务-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <constructor-arg ref="datasource" />
    </bean>
    <!--结合aop实现事务织入-->
    <!--配置事务的通知类-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager" >
        <!--给哪些方法配置事务-->
        <!--新东西:配置事务的传播特性 propagation-->
        <tx:attributes>
            <tx:method name="insert"/>
            <tx:method name="del" propagation="REQUIRED"/>
            <tx:method name="getUser" propagation="REQUIRED"/>
            <tx:method name="*"/>

        </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>
</beans>
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
其中spring七个事物传播属性:

PROPAGATION_REQUIRED – 支持当前事务,如果当前没有事务,就新建一个事务。这是最常见的选择。
 PROPAGATION_SUPPORTS – 支持当前事务,如果当前没有事务,就以非事务方式执行。
 PROPAGATION_MANDATORY – 支持当前事务,如果当前没有事务,就抛出异常。
 PROPAGATION_REQUIRES_NEW – 新建事务,如果当前存在事务,把当前事务挂起。
 PROPAGATION_NOT_SUPPORTED – 以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。
 PROPAGATION_NEVER – 以非事务方式执行,如果当前存在事务,则抛出异常。
 PROPAGATION_NESTED – 如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,
则进行与PROPAGATION_REQUIRED类似的操作。

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

        <!-- 导入spring-dao.xml -->
        <import resource="spring-dao.xml"/>

    <bean id="userMapper" class="com.kuang.mapper.UserMapperImpl">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
    </bean>

</beans>
1234567891011121314151617

测试类

public class MyTest {

    @Test
    public void test02(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserMapper userMapper = (UserMapper) context.getBean("userMapper");

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

123456789101112131415

anager=“transactionManager” >

tx:attributes
<tx:method name=“insert”/>
<tx:method name=“del” propagation=“REQUIRED”/>
<tx:method name=“getUser” propagation=“REQUIRED”/>
<tx:method name="*"/>

    </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>
1234567

```回顾事务

  • 事务在项目开发过程非常重要,涉及到数据的一致性的问题,不容马虎!
  • 事务管理是企业级应用程序开发中必备技术,用来确保数据的完整性和一致性。

事务就是把一系列的动作当成一个独立的工作单元,这些动作要么全部完成,要么全部不起作用。

事务四个属性ACID

  1. 原子性(atomicity)

    • 事务是原子性操作,由一系列动作组成,事务的原子性确保动作要么全部完成,要么完全不起作用
  2. 一致性(consistency)

    • 一旦所有事务动作完成,事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中
  3. 隔离性(isolation)

    • 可能多个事务会同时处理相同的数据,因此每个事务都应该与其他事务隔离开来,防止数据损坏
  4. 持久性(durability)

    • 事务一旦完成,无论系统发生什么错误,结果都不会受到影响。通常情况下,事务的结果被写到持久化存储器中

测试

将上面的代码拷贝到一个新项目中

在之前的案例中,我们给userDao接口新增两个方法,删除和增加用户;

//添加一个用户int addUser(User user);//根据id删除用户int deleteUser(int id);

mapper文件,我们故意把 deletes 写错,测试!

<insert id="addUser" parameterType="com.kuang.pojo.User">insert into user (id,name,pwd) values (#{id},#{name},#{pwd})</insert><delete id="deleteUser" parameterType="int">deletes from user where id = #{id}</delete>

编写接口的实现类,在实现类中,我们去操作一波

public class UserDaoImpl extends SqlSessionDaoSupport implements UserMapper {   //增加一些操作   public List<User> selectUser() {       User user = new User(4,"小明","123456");       UserMapper mapper = getSqlSession().getMapper(UserMapper.class);       mapper.addUser(user);       mapper.deleteUser(4);       return mapper.selectUser();  }   //新增   public int addUser(User user) {       UserMapper mapper = getSqlSession().getMapper(UserMapper.class);       return mapper.addUser(user);  }   //删除   public int deleteUser(int id) {       UserMapper mapper = getSqlSession().getMapper(UserMapper.class);       return mapper.deleteUser(id);  }}

测试

@Testpublic void test2(){   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");   UserMapper mapper = (UserMapper) context.getBean("userDao");   List<User> user = mapper.selectUser();   System.out.println(user);}

报错:sql异常,delete写错了

结果 :插入成功!

没有进行事务的管理;我们想让他们都成功才成功,有一个失败,就都失败,我们就应该需要事务!

以前我们都需要自己手动管理事务,十分麻烦!

但是Spring给我们提供了事务管理,我们只需要配置即可;

Spring中的事务管理

Spring在不同的事务管理API之上定义了一个抽象层,使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。

编程式事务管理

  • 将事务管理代码嵌到业务方法中来控制事务的提交和回滚
  • 缺点:必须在每个事务操作业务逻辑中包含额外的事务管理代码

声明式事务管理

  • 一般情况下比编程式事务好用。
  • 将事务管理代码从业务方法中分离出来,以声明的方式来实现事务管理。
  • 将事务管理作为横切关注点,通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。

使用Spring管理事务,注意头文件的约束导入 : tx

xmlns:tx="http://www.springframework.org/schema/tx"http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx.xsd">

事务管理器

  • 无论使用Spring的哪种事务管理策略(编程式或者声明式)事务管理器都是必须的。
  • 就是 Spring的核心事务管理抽象,管理封装了一组独立于技术的方法。

JDBC事务

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">       <property name="dataSource" ref="dataSource" /></bean>

配置好事务管理器后我们需要去配置事务的通知

<!--配置事务通知--><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="search*" propagation="REQUIRED"/>       <tx:method name="get" read-only="true"/>       <tx:method name="*" propagation="REQUIRED"/>   </tx:attributes></tx:advice>

spring事务传播特性:

事务传播行为就是多个事务方法相互调用时,事务如何在这些方法间传播。spring支持7种事务传播行为:

  • propagation_requierd:如果当前没有事务,就新建一个事务,如果已存在一个事务中,加入到这个事务中,这是最常见的选择。
  • propagation_supports:支持当前事务,如果没有当前事务,就以非事务方法执行。
  • propagation_mandatory:使用当前事务,如果没有当前事务,就抛出异常。
  • propagation_required_new:新建事务,如果当前存在事务,把当前事务挂起。
  • propagation_not_supported:以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。
  • propagation_never:以非事务方式执行操作,如果当前事务存在则抛出异常。
  • propagation_nested:如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则执行与propagation_required类似的操作

Spring 默认的事务传播行为是 PROPAGATION_REQUIRED,它适合于绝大多数的情况。

假设 ServiveX#methodX() 都工作在事务环境下(即都被 Spring 事务增强了),假设程序中存在如下的调用链:Service1#method1()->Service2#method2()->Service3#method3(),那么这 3 个服务类的 3 个方法通过 Spring 的事务传播机制都工作在同一个事务中。

就好比,我们刚才的几个方法存在调用,所以会被放在一组事务当中!

配置AOP

导入aop的头文件!

<!--配置aop织入事务--><aop:config>   <aop:pointcut id="txPointcut" expression="execution(* com.kuang.dao.*.*(..))"/>   <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/></aop:config>

进行测试

删掉刚才插入的数据,再次测试!

@Testpublic void test2(){   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");   UserMapper mapper = (UserMapper) context.getBean("userDao");   List<User> user = mapper.selectUser();   System.out.println(user);}
l异常,delete写错了

结果 :插入成功!

没有进行事务的管理;我们想让他们都成功才成功,有一个失败,就都失败,我们就应该需要**事务!**

以前我们都需要自己手动管理事务,十分麻烦!

但是Spring给我们提供了事务管理,我们只需要配置即可;



> Spring中的事务管理

Spring在不同的事务管理API之上定义了一个抽象层,使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。

**编程式事务管理**

- 将事务管理代码嵌到业务方法中来控制事务的提交和回滚
- 缺点:必须在每个事务操作业务逻辑中包含额外的事务管理代码

**声明式事务管理**

- 一般情况下比编程式事务好用。
- 将事务管理代码从业务方法中分离出来,以声明的方式来实现事务管理。
- 将事务管理作为横切关注点,通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。

**使用Spring管理事务,注意头文件的约束导入 : tx**

xmlns:tx=“http://www.springframework.org/schema/tx"http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx.xsd”>


**事务管理器**

- 无论使用Spring的哪种事务管理策略(编程式或者声明式)事务管理器都是必须的。
- 就是 Spring的核心事务管理抽象,管理封装了一组独立于技术的方法。

**JDBC事务**


**配置好事务管理器后我们需要去配置事务的通知**


**spring事务传播特性:**

事务传播行为就是多个事务方法相互调用时,事务如何在这些方法间传播。spring支持7种事务传播行为:

- propagation_requierd:如果当前没有事务,就新建一个事务,如果已存在一个事务中,加入到这个事务中,这是最常见的选择。
- propagation_supports:支持当前事务,如果没有当前事务,就以非事务方法执行。
- propagation_mandatory:使用当前事务,如果没有当前事务,就抛出异常。
- propagation_required_new:新建事务,如果当前存在事务,把当前事务挂起。
- propagation_not_supported:以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。
- propagation_never:以非事务方式执行操作,如果当前事务存在则抛出异常。
- propagation_nested:如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则执行与propagation_required类似的操作

Spring 默认的事务传播行为是 PROPAGATION_REQUIRED,它适合于绝大多数的情况。

假设 ServiveX#methodX() 都工作在事务环境下(即都被 Spring 事务增强了),假设程序中存在如下的调用链:Service1#method1()->Service2#method2()->Service3#method3(),那么这 3 个服务类的 3 个方法通过 Spring 的事务传播机制都工作在同一个事务中。

就好比,我们刚才的几个方法存在调用,所以会被放在一组事务当中!

**配置AOP**

导入aop的头文件!


**进行测试**

删掉刚才插入的数据,再次测试!

@Testpublic void test2(){ ApplicationContext context = new ClassPathXmlApplicationContext(“beans.xml”); UserMapper mapper = (UserMapper) context.getBean(“userDao”); List user = mapper.selectUser(); System.out.println(user);}

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 深蓝海洋 设计师:CSDN官方博客 返回首页