Spring5

这篇具有很好参考价值的文章主要介绍了Spring5。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Spring5

一.框架概述

1.Spring是轻量级开源JavaEE框架

轻量级:体积比较小,引入的jar包比较少也比较小,可以独立进行使用

开源:可以免费提供源代码

2.Spring可以解决企业应用开发的复杂性,使开发更简洁,方便

3.Spring的两个核心部分分别是:IOCAOP

(1).IOC:控制反转, 把创建对象的过程交给Spring进行管理,不在需要我们使用new来创建了

(2).AOP:面向切面,不修改源代码的情况下,增强功能

4.Spring特点

(1).方便解耦,简化开发

解耦:模块间关联程度降低

(2).AOP编程的支持

(3).方便程序的测试

(4).方便和其他框架进行整合(使用)

(5).方便进行事物的操做(方便集成各种优秀的框架)

(6).降低API的开发难度

对很多东西进行的封装,例如JDBC

二.入门案例

创建一个普通的java工程,在工程下创建一个libs目录,导入core,bean,expression,context,commons-logging这些jar包

src下创建一个spring Config文件

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

    <bean id="user" class="com.User"></bean>
</beans>

在src下创建一个com包,在com包下创建一个User类

public class User {
    public void add(){
        System.out.println("add.....");
    }
}

在com包下创建test包,在test包下创建test类

public class test {
    @Test
    public void testadd(){

        //1.加载Spring配置文件
        ApplicationContext context  = new ClassPathXmlApplicationContext("bean1.xml");
        //2.获取配置文件创建的对象
        User user = context.getBean("user", User.class);

        System.out.println(user);

        user.add();

    }

}

三.IOC容器

1.IOC概念

(1).控制反转,把对象创建对象间的调用过程,交给Spring进行管理

(2).使用IOC的目的:为了耦合度降低

(3).上面的入门案例,就是IOC的实现

2.IOC底层原理

  • xml解析

  • 工厂模式

  • 反射

Spring5
Spring5

Spring5

3.IOC接口

(1).IOC思想基于IOC容器完成,IOC容器底层就是对象工厂

(2).Spring提供IOC容器两种实现方式(两个接口)

  • BeanFactory:IOC容器基本实现,是Spring内部的使用接口,不提供开发人员进行使用

​ 特点:加载配置文件时候不会创建对象,在使用时才会创建对象

  • ApplicationContext:BeanFactory接口的子接口,提供更多强大的功能,一般由开发人员进行使用

    特点:加载配置文件的时候,进行对象的创建

(3).ApplicationContext接口实现类

Spring5

FileSystemXmlApplicationContext特点:在构造方法中,写的是xml文件系统盘里的路径

ClassPathXmlApplicationContext特点:在构造方法中,写的是xml文件src里的路径

四.IOC操做Bean管理

1.Bean管理

(1).Spring创建对象

(2).Spring注入属性

2.基于xml配置文件方式实现

(1).创建对象
  • 在Spring配置文件中,使用bean标签,标签里面添加对应的属性,就可以实现对象创建
  • id属性:唯一标识
  • class属性:类全路径
  • 创建对象的时候,默认也是执行无参构造方法完成对象创建
(2).注入属性

DI:依赖注入,就是注入属性(IOC中的一个具体实现,在创建对象的基础上)

第一种注入:set方法

第一步:创建类,定义属性和对应的set方法

public class Book {

    private String bname;
    private String bauthor;
    //set方法注入
    public void setBname(String bname) {
        this.bname = bname;
    }

    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }
}

第二步:在Spring配置文件配置对象创建,配置属性注入

  <!--set方法注入属性-->
    <bean id="book" class="com.Book">
        <!--
                使用property完成属性注入
                name:类里面的属性名称
                value:向属性注入的值
        -->
        <property name="bname" value="易筋经"></property>
        <property name="bauthor" value="达摩老祖"></property>

    </bean>

测试:

 public void testBook1(){

        //1.加载Spring配置文件
        ApplicationContext context  = new ClassPathXmlApplicationContext("bean1.xml");
        //2.获取配置文件创建的对象
        Book book = context.getBean("book", Book.class);

        System.out.println(book);

        book.testDemo();

    }
第二种注入:有参数的构造

第一步:创建类,定义属性和对应的有参构造方法

public class Orders {

private String oname;
private String address;

    public void setOname(String oname,String address) {
        this.oname = oname;
        this.address = address;
    }
    public  void orderTest(){
        System.out.println(oname + "::" + address);
    }
}

第二步:在Spring配置文件中进行配置

 <!--有参构造注入属性-->
    <bean id="order" class="com.Orders">

        <constructor-arg name="oname" value="电脑"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
       

    </bean>

也可以这么写(通过索引)

<!--有参构造注入属性-->
    <bean id="order" class="com.Orders">

        <constructor-arg index="0" value="电脑"></constructor-arg>
        <constructor-arg index="1" value="China"></constructor-arg>

    </bean>

测试:

public void testOrders(){
        //1.加载Spring配置文件
        ApplicationContext context  = new ClassPathXmlApplicationContext("bean1.xml");
        //2.获取配置文件创建的对象
        Orders order = context.getBean("order",Orders.class);
        order.orderTest();
    }
p名称空间注入(了解)

可以简化基于xml配置方式,应用的还是set方法注入

第一步,在配置文件中添加p名称空间

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="user" class="com.User"></bean>

第二步,进行属性注入,在bean标签里面进行操做

 <!--set方法注入属性-->
    <bean id="book" class="com.Book" p:bname="易筋经" p:bauthor="达摩老祖">
    </bean>
注入空值和特殊符号
  • null值

    <bean id="book" class="com.Book">
            <property name="address">
                <null/>
            </property>
        </bean>
    
  • 属性值包含特殊符号(例如,<>)

    <!--
    1.把特殊符号进行转义 &lt; &gt;
    2.把带特殊符号内容写到CDATA
    -->
    <bean id="book" class="com.Book">
            <property name="address">
                <value><![CDATA[<<南京>>]]></value>
            </property>
    </bean>        
    
外部Bean

(1).创建两个类service类和dao类

public class UserService {

    //创建UserDao类型的属性
   private UserDao userDao;

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

public void add(){

    System.out.println("service add.......");
    userDao.update();

      }   

}
public class UserDaoImpl implements UserDao{

    public void update(){
        
     System.out.println("dao update.......");

    }
   
}

(2).在service中调用dao里面的方法

public void testAdd(){
       //1.加载Spring配置文件
       ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");

       UserService userService = context.getBean("userService", UserService.class);

       userService.add();
   }

(3).在Spring配置文件中进行配置

  <bean id="userService" class="com.service.UserService">
        <!--
              注入UserDao对象
              name:类里面属性名称
              ref:创建UserDao对象,bean标签id值
        -->
        <property name="userDao" ref="userDao"></property>

    </bean>

    <bean id="userDao" class="com.dao.UserDaoImpl"></bean>
内部Bean和级联赋值

(1).一对多关系:部门和员工

(2).在实体类之间表示一对多关系

(3).在Spring配置文件中进行配置

内部Bean

public class Emp {

    private String ename;
    private String gender;
    private Dept dept;

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void add(){

        System.out.println(ename + "::" + gender + "::" + dept);

    }
}
public class Dept {


    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }

}
  <!--内部bean-->
     <bean id="emp" class="com.bean.Emp">
         <!--设置两个普通属性-->
         <property name="ename" value="lucy"></property>
         <property name="gender" value=""></property>
         <property name="dept">
             <bean id="dept" class="com.bean.Dept">
                 <property name="dname" value="安保部"></property>
             </bean>
         </property>
     </bean>

测试:

 public void testBean(){
        //1.加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");

        Emp emp = context.getBean("emp", Emp.class);

        emp.add();
    }

级联赋值

第一种写法

<bean id="emp" class="com.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="lucy"></property>
        <property name="gender" value=""></property>
        <!--级联赋值-->
        <property name="dept" ref="dept"></property>
    </bean>
    <bean id="dept" class="com.bean.Dept">

        <property name="dname" value="财务部"></property>

    </bean>

第二种写法

 <bean id="emp" class="com.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="lucy"></property>
        <property name="gender" value=""></property>
        <!--级联赋值-->
        <property name="dept" ref="dept"></property>
        <property name="dept.dname" value="技术部"></property>
    </bean>
    <bean id="dept" class="com.bean.Dept">
    </bean>

注意,在第二种写法中,要在Emp类中添加对象属性的get方法,否则在配置文件中会报错误

注入集合属性

1.注入数组类型属性

2.注入List集合类型属性

3.注入Map集合类型属性

4.注入Set集合类型属性

(1).创建类,定义属性,生成set方法

public class Stu {

    //1.数组类型属性
    private String[] courses;

    //2.List集合类型属性

    private List<String> list;

    //3.map集合类型属性
    private Map<String,String> map;

    //4.set集合属性
    private Set<String> sets;

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setCourses(String[] courses){
        this.courses = courses;
    }

}

(2).在Spring文件中进行配置

 <bean id="stu" class="com.Stu">
          <!--注入数组类型属性-->
          <property name="courses">
              <array>
                  <value>小红</value>
                  <value>小黄</value>
              </array>
          </property>
          <!--注入List集合类型属性-->
          <property name="list">
              <list>
                  <value>小蓝</value>
                  <value>小绿</value>
              </list>
          </property>
          <!--注入Map集合类型属性-->
          <property name="map">
              <map>
                  <entry key="小刘" value="123"> </entry>
                  <entry key="小李" value="456"> </entry>
              </map>
          </property>
          <!--注入Set集合类型属性-->
         <property name="sets">
             <set>
                 <value>MySql</value>
                 <value>Redis</value>
             </set>
         </property>
      </bean>
集合元素是对象类型

(1).创建一个类

public class Course {

    private String cname;

    public void setCname(String cname) {
        this.cname = cname;
    }

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

(2).在Stu类中定义属性

 private List<Course> courseList;

(3).在Spring配置文件中配置

    <bean id="stu" class="com.Stu">
          <property name="courseList">
              <list>
                  <ref bean="course1"></ref>
                  <ref bean="course2"></ref>
              </list>
          </property>
      </bean>

    <bean id="course1" class="com.Course">
        <property name="cname" value="Spring5"></property>
    </bean>
    <bean id="course2" class="com.Course">
        <property name="cname" value="MyBatis"></property>
    </bean>

测试:

public void testcollection(){
    
 ApplicationContext context =
         new ClassPathXmlApplicationContext("bean1.xml");
    
      Stu stu = context.getBean("stu",Stu.class);
    
      stu.test();
    
     }
把集合注入部分提取出来

(1).在Spring配置文件中引入名称空间

 xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

(2).使用util标签完成list集合注入提取

<!--1.提取List集合类型属性注入-->
    <util:list id="bookList">
        <value>易筋经</value>
        <value>九阴真经</value>
        <value>九阳神功</value>
    </util:list>

<!--2.使用-->
    <bean id="book" class="com.Book">
        <property name="list" ref="bookList"></property>
    </bean>
工厂bean

Spring中有两种类型的bean,分别是:

  • 普通类型:在配置文件中定义的bean类型,就是返回类型

  • 工厂bean(Spring内置的一种类型):在配置文件中定义的bean类型和返回类型不一样

    第一步,创建类,让这个类成为工厂bean,实现接口FactoryBean

    第二步,实现接口里面的方法,在实现的方法中定义返回的bean类型

    public class MyBean implements FactoryBean<Course> {
    
        @Override
        public boolean isSingleton() {
            return false;
        }
              //定义返回bean
        @Override
        public Course getObject() throws Exception {
            Course course = new Course();
            course.setCname("abc");
            return course;
        }
    
        @Override
        public Class<?> getObjectType() {
            return null;
        }
    }
    
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
        <bean id="myBean" class="facbean.MyBean"></bean>
    </beans>
    
bean的作用域

Spring里面,默认情况下,bean是单实例对象

(1).设置bean是单实例还是多实例,在bean标签中使用scope属性

(2).scope属性值

singleton表示单实例对象

prototype表示多实例对象

 <bean id="book" class="com.Book" scope="prototype">
        <property name="list" ref="bookList"></property>
    </bean>

(3).设置scope值是singleton的时候,是在加载Spring配置文件的时候创建单实例对象

​ 设置scope值是prototype的时候,是在调用getBean方法获取对象的时候创建多实例对象

bean的生命周期

(1).通过构造器创建bean实例(无参构造)

(2).为bean的属性设置值和对其他bean引用(调用set方法)

(3).调用bean的初始化的方法(需要进行配置初始化的方法)

(4).bean可以使用了(获取到了)

(5).当容器关闭的时候,调用bean的销毁的方法(需要进行配置销毁的方法)

public class Orders {


    public Orders() {

        System.out.println("第一步,执行无参数的构造创建bean实例");
    }

    private String oname;

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步,调用set方法设置属性值");
    }

    public void initMethod(){

        System.out.println("第三步,执行初始化的方法");
    }

    public void destroyMethod(){

        System.out.println("第五步,执行销毁的方法");

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


    <bean id="orders" class="bean.Orders" init-method="initMethod" destroy-method="destroyMethod">

        <property name="oname" value="手机"></property>
    </bean>


</beans>
  public void testcollection3(){

        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("bean4.xml");
        Orders orders = context.getBean("orders", Orders.class);
        System.out.println("第四步,获取bean对象");
        context.close();
    }
bean的后置处理器

(1).通过构造器创建bean实例(无参构造)

(2).为bean的属性设置值和对其他bean引用(调用set方法)

(3).把bean实例传第bean后置处理器的方法

(4).调用bean的初始化的方法(需要进行配置初始化的方法)

(5).把bean实例传第bean后置处理器的方法

(6).bean可以使用了(获取到了)

(7).当容器关闭的时候,调用bean的销毁的方法(需要进行配置销毁的方法)

public class MyBeanPost implements BeanPostProcessor {


    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之后执行的方法");
        return 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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


    <bean id="orders" class="bean.Orders" init-method="initMethod" destroy-method="destroyMethod">

        <property name="oname" value="手机"></property>
    </bean>


    <!--配置后置处理器-->
    <bean id="myBeanPost" class="bean.MyBeanPost"></bean>

</beans>
 public void testcollection3(){

        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("bean4.xml");
        Orders orders = context.getBean("orders", Orders.class);
        System.out.println("第四步,获取bean对象");
        context.close();
    }

注意:由于MyBeanPost类实现了 BeanPostProcessor接口,Spring就会把MyBeanPost当作后置处理器,后置处理器会对当前配置文件中的所有bean都添加后置处理器的处理

自动装配

概念:根据指定装配规则(属性名称或者属性类型),Spring自动将匹配的属性值进行注入

public class Emp {
    private Dept dept;

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "dept=" + dept +
                '}';
    }

    public void test(){

        System.out.println(dept);

    }

}
public class Dept {

    @Override
    public String toString() {
        return "Dept{}";
    }
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


    <!--实现自动装配
    bean标签属性autowire,配置自动装配
    autowire属性常用的两个值:byName(根据属性名称)和byType(根据属性类型)
    -->

    <bean id="emp" class="autowire.Emp" autowire="byName"></bean>
    <bean id="dept" class="autowire.Dept"></bean>


</beans>

注意:如果同一个类型bean被创建多次,就不能使用byType进行自动装配

外部属性文件

1.直接配置数据库信息

(1).配置德鲁伊连接池

(2).引入德鲁伊连接池依赖jar包

<!--直接配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">

    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
    <property name="username" value="root"></property>
    <property name="password" value="wwyyll123"></property>
</bean>

2.引入外部属性文件配置数据库连接池

(1).创建外部属性文件,properties格式文件,写数据库信息

prop.driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/userDb
username=root
password=wwyyll123

(2).把外部properties属性文件,引入到Spring配置文件中

 <!--引入外部属性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">

        <property name="driverClassName" value="${prop.driverClassName}"></property>
        <property name="url" value="${url}"></property>
        <property name="username" value="${username}"></property>
        <property name="password" value="${password}"></property>
    </bean>

3.基于注解方式实现

注解概念:

(1).注解是代码特殊标记,格式:@注解名称(属性名称=属性值,属性名称=属性值…)

(2).注解作用在上面,方法上面,属性上面

(3).使用注解的目的:简化xml配置

Spring针对Bean管理创建对象提供注解:

(1).@Component

(2).@Service

(3).@Controller

(4).@Repository

上面四个注解功能是一样的,都可以用来创建bean实例

创建对象

第一步,引入依赖

Spring5

第二步,开启组件扫描

告诉Spring容器,哪个中哪个里面有注解,然后对其创建对象,否则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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--开启组件扫描
     1.如果扫描多个包,多个包之间用逗号隔开
     2.也可以扫描包上层目录(com)
    -->
    
    <context:component-scan base-package="com.dao,com.service"></context:component-scan>

</beans>

第三步,创建类,在类上面添加创建对象注解

//value属性值可以省略不写,
//如果不写,默认是类名称,首字母小写

@Component(value = "userService")//相当于<bean id="userService" class=""></bean>
public class UserService {

public void add(){

    System.out.println("service add.....");

}

测试:

public class testService {
@Test
    public void test1() {

        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();

    }
}

组件扫描的细节

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

    <!--开启组件扫描
     1.如果扫描多个包,多个包之间用逗号隔开
     2.也可以扫描包上层目录(com)
    -->

    <context:component-scan base-package="com"></context:component-scan>


    <!--示例1
    use-default-filters="false" 表示现在不使用默认filter,自己配置filter
    context:include-filter,设置扫描哪些内容
    -->
    <context:component-scan base-package="com" use-default-filters="false">

        <context:include-filter type="annotation" expression=" org.springframework.stereotype.Component"/>

    </context:component-scan>

    <!--示例2
    配置扫描所有内容
    context:exclude-filter:设置哪些内容不进行扫描
    -->
    <context:component-scan base-package="com">
       <context:exclude-filter type="annotation" expression=" org.springframework.stereotype.Component"/>
    </context:component-scan>



</beans>
注入属性

(1).@AutoWired:根据属性类型进行自动装配

第一步,把service和dao对象创建,在service和dao类添加创建对象注解

第二步,在service注入dao对象,在service类中添加dao类型属性,在属性上面使用注解

(2).@Qualifier:根据属性名称进行注入

和上面的@Autowired一起使用

@Service
public class UserService {
@Autowired
@Qualifier(value="userDaoImpl1")
    private UserDao userDao;

public void add(){

    System.out.println("service add.....");
    userDao.add();

    }

}
@Repository(value="userDaoImpl1")
public class UserDaoImpl implements UserDao{

    @Override
    public void add() {
        System.out.println("dao add.....");
    }
}

(3).@Resource:可以根据类型注入,也可以根据名称进行注入

    //@Resource
    @Resource(name="userDaoImpl1")
    private UserDao userDao;

(4).@Value:注入普通类型属性

@Value(value = "abc")
private String name;
完全注解开发

(1).创建配置类,替代xml配置文件

@Configuration//作为配置类,替代xml配置文件
@ComponentScan(basePackages = {"com"})
public class SpringConfig {
}

(2).测试

public void test2() {

    ApplicationContext context =
            new AnnotationConfigApplicationContext(SpringConfig.class);
    UserService userService = context.getBean("userService", UserService.class);
    userService.add();
}

五.AOP

1.基本概念

(1).面向切面编程(方面),可以降低业务逻辑的各部分之间的耦合度,可以提高开发效率

(2).通俗解释:可以不通过修改源代码的方式来添加新功能

2.底层原理

AOP底层使用动态代理

(1).两种动态代理

第一种,有接口情况,使用JDK动态代理

Spring5

第二种,没有接口情况,使用CGLIB动态代理

Spring5

(2).JDK动态代理实现

使用JDK动态代理,使用Proxy类里面的方法创建代理对象

Spring5

此方法有三个参数:

第一个参数,类加载器

第二个参数,增强方法所在的类,这个类实现的接口,支持多个接口

第三个参数,实现这个接口InvocationHandler,创建代理对象,写增强的方法

编写JDK动态代理代码

(1).创建接口,定义方法

public interface UserDao {

    public int add(int a,int b);

    public String update(String id);

}

(2).创建接口实现类,实现方法

public class UserDaoImpl implements UserDao{

    @Override
    public int add(int a, int b) {
        return a + b;
    }

    @Override
    public String update(String id) {
        return id;
    }
}

(3).使用Proxy类创建接口代理对象

public class JDKProxy {

    public static void main(String[] args) {

        //创建接口实现类代理对象
        Class[] interfaces = {UserDao.class};

        UserDaoImpl userDao = new UserDaoImpl();

        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));

        int result = dao.add(1,2);

        System.out.println("result:" + result);
    }

}

class UserDaoProxy implements InvocationHandler{

    //1.创建的是谁的代理对象,把谁传递过来
    //有参数构造传递

    private Object obj;

    public UserDaoProxy(Object obj){

        this.obj = obj;

    }

    //增强的逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

     //方法之前
        System.out.println("方法之前执行..." + method.getName() + ":传递的参数..." + Arrays.toString(args));

     //被增强的方法执行
        Object res = method.invoke(obj,args);

     //方法之后
        System.out.println("方法之后执行..." + obj);
        return res;
    }
}

3.操做术语

(1).连接点

类里面哪些方法可以被增强,这些方法称为连接点

(2).切入点

实际被真正增强的方法,称为切入点

(3).通知(增强)

  • 实际增强的逻辑部分称为通知(增强)

  • 通知有多种类型

    • 前置通知,在被增强的方法前执行
    • 后置通知,在被增强的方法后执行
    • 环绕通知,在被增强的方法前后都执行
    • 异常通知,在被增强的方法出现异常时执行
    • 最终通知,不管被增强的方法异常不异常,最后都执行,相当于finally

(4).切面(是一个动作)

通知应用到切入点过程

4.准备工作

(1).Spring框架一般都是基于AspectJ实现AOP操做

  • AspectJ不是Spring组成部分,独立AOP框架,一般把AspectJSpring框架一起使用,进行AOP操做

(2).基于AspectJ实现AOP操做

  • 基于xml配置文件实现
  • 基于注解方式实现

(3).在项目工程里面引入AOP相关依赖

Spring5

(4).切入点表达式

  • 作用:知道对哪个类里面的哪个方法进行增强

  • execution([权限修饰符] [返回类型] [类全路径] [方法名称] [参数列表])

    举例1:

    对com.Service类里面的add进行增强

    execution(* com.Service.add(…))

    举例2:

    对com.Service类里面的所有方法进行增强

    execution(* com.Service.*(…))

    举例3:

    对com包里面的所有类,类里面的所有方法进行增强

    execution(* com. *. *(…))

​ 注意:*表示所有,返回类型可以省略

5.AspectJ注解

(1).创建类,在类里面定义方法

public class User {

    public void add(){

        System.out.println("add...");

    }

}

(2).创建增强类(编写增强逻辑)

增强类里面,创建方法,让不同方法代表不同通知类型

//增强的类
public class UserProxy {

    //前置通知
    public void before(){

        System.out.println("before.....");

    }

}

(3).进行通知的配置

  • 在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:context="http://www.springframework.org/schema/context"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                               http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                               http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    
        <!--开启组件扫描-->
        <context:component-scan base-package="com.aopanno"></context:component-scan>
    
    </beans>
    
  • 使用注解创建User和UserProxy对象

    //被增强的类
    @Component
    public class User {
    
        public void add(){
    
            System.out.println("add...");
    
        }
    
    }
    
    //增强的类
    @Component
    public class UserProxy {
    
        //前置通知
        public void before(){
    
            System.out.println("before.....");
    
        }
    
    }
    
  • 增强类上面添加注解@AspectJ

    //增强的类
    @Component
    @Aspect  //生成代理对象
    public class UserProxy {
    
        //前置通知
        public void before(){
    
            System.out.println("before.....");
    
        }
    
    }
    
  • 在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:context="http://www.springframework.org/schema/context"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                               http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                               http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
                               
        <!--开启AspectJ生成代理对象-->
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
    </beans>
    

(4).配置不同类型的通知

增强类里面,在作为通知的方法上面添加通知类型注解,使用切入点表达式配置

//增强的类
@Component
@Aspect  //生成代理对象
public class UserProxy {

    //前置通知
    @Before(value = "execution(* com.aopanno.User.add(..))")
    public void before(){

        System.out.println("before.....");

    }

}

测试:

@Test
public void test1(){

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

    User user = context.getBean("user",User.class);

    user.add();

}

不同类型通知的配置

package com.aopanno;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

//增强的类
@Component
@Aspect  //生成代理对象
public class UserProxy {

    //前置通知
    @Before(value = "execution(* com.aopanno.User.add(..))")
    public void before(){

        System.out.println("before.....");

    }
    //后置通知(返回通知)返回值之后执行
    @AfterReturning(value = "execution(* com.aopanno.User.add(..))")
    public void afterReturning(){

        System.out.println("afterReturning.....");

    }
    //最终通知
    @After(value = "execution(* com.aopanno.User.add(..))")
    public void after(){

        System.out.println("after.....");

    }
    //异常通知
    @AfterThrowing(value = "execution(* com.aopanno.User.add(..))")
    public void afterThrowing(){

        System.out.println("afterThrowing.....");

    }
    //环绕通知
    @Around(value = "execution(* com.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{

        System.out.println("环绕之前...");

        //被增强的方法执行
        proceedingJoinPoint.proceed();

        System.out.println("环绕之后...");

    }

}

(5).相同切入点的抽取

@Pointcut(value = "execution(* com.aopanno.User.add(..))")
 public void pointdemo(){

 }

 //前置通知
 @Before(value = "pointdemo()")
 public void before(){

     System.out.println("before.....");

 }

(6).有多个增强类对同一个方法进行增强,设置增强类优先级

增强类上面添加注解@Order(数字类型值),数字类型值越小优先级越高

import org.springframework.stereotype.Component;

@Component
@Aspect  //生成代理对象
@Order(1)
public class PersonProxy {

    //前置通知
    @Before(value = "execution(* com.aopanno.User.add(..))")
    public void afterReturning(){

        System.out.println("Person Before.....");

    }

}
//增强的类
@Component
@Aspect  //生成代理对象
@Order(3)
public class UserProxy {

   @Pointcut(value = "execution(* com.aopanno.User.add(..))")
    public void pointdemo(){

    }

    //前置通知
    @Before(value = "pointdemo()")
    public void before(){

        System.out.println("before.....");

    }
    //后置通知(返回通知)返回值之后执行
    @AfterReturning(value = "execution(* com.aopanno.User.add(..))")
    public void afterReturning(){

        System.out.println("afterReturning.....");

    }
    //最终通知
    @After(value = "execution(* com.aopanno.User.add(..))")
    public void after(){

        System.out.println("after.....");

    }
    //异常通知
    @AfterThrowing(value = "execution(* com.aopanno.User.add(..))")
    public void afterThrowing(){

        System.out.println("afterThrowing.....");

    }
    //环绕通知
    @Around(value = "execution(* com.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{

        System.out.println("环绕之前...");

        //被增强的方法执行
        proceedingJoinPoint.proceed();

        System.out.println("环绕之后...");

    }

}

(7).完全注解开发

创建配置类,不需要创建xml文件

@Configuration
@ComponentScan(basePackages = {"com"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {

}

6.AspectJ配置文件

(1).创建两个类,增强类和被增强类,创建方法

//被增强类
public class Book {

    public void buy(){

        System.out.println("buy.........");

    }

}
//增强类
public class BookProxy {

    public void before(){

        System.out.println("before........");

    }
    
}

(2).在Spring配置文件中创建两个类对象

<!--创建对象-->
<bean id="book" class="com.aopxml.Book"></bean>
<bean id="bookProxy" class="com.aopxml.BookProxy"></bean>

(3).在Spring配置文件中配置aop增强

<!--配置aop增强-->
<aop:config>
    <!--配置切入点-->
    <aop:pointcut id="p" expression="execution(* com.aopxml.Book.buy(..))"/>

    <!--配置切面-->
    <aop:aspect ref="bookProxy">
     <!--增强作用在具体的方法上-->
      <aop:before method="before" pointcut-ref="p"/>
    </aop:aspect>
</aop:config>

测试:

@Test
public void test2(){

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

    Book book = context.getBean("book",Book.class);

    book.buy();

}

六.JdbcTemplate

1.概述和准备工作

(1).概述

Spring框架对JDBC进行封装,使用JdbcTemplate方便实现对数据库操做

(2).准备工作

  • 引入相关jar包

Spring5

  • 在Spring配置文件中配置数据库连接池

     <!--数据库连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
    destroy-method="close">
    
         <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
         <property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
         <property name="username" value="root"></property>
         <property name="password" value="wwyyll123"></property>
    
     </bean>
    
  • 配置JdbcTemplate对象,注入DataSource

    <!--JdbcTemplate对象-->
     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
         <!--注入datasource-->
         <property name="dataSource" ref="dataSource"></property>
     </bean>
    
  • 创建service类,dao类,在dao注入JdbcTemplate对象

    @Service
    public class BookService {
    
        //注入dao
        @Autowired
        private BookDao bookDao;
    
    }
    
    @Repository
    public class BookDaoImpl implements BookDao{
    
    //注入JdbcTemplate
        @Autowired
        private JdbcTemplate jdbcTemplate;
    
    }
    

2.操做数据库

(1).添加功能
  • 对应数据库创建实体类

    public class Book {
    
        private String userId;
        private String username;
        private String ustatus;
    
        public void setUserId(String userId) {
            this.userId = userId;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public void setUstatus(String ustatus) {
            this.ustatus = ustatus;
        }
    
        public String getUserId() {
            return userId;
        }
    
        public String getUsername() {
            return username;
        }
    
        public String getUstatus() {
            return ustatus;
        }
    }
    
  • 编写service和dao

    • 在dao里面进行数据库添加操做

    • 调用JdbcTemplate对象里面的update方法实现添加操做
      Spring5

      • 有两个参数

      • 第一个参数:sql语句

      • 第二个参数:可变参数,设置sql语句值

        @Repository
        public class BookDaoImpl implements BookDao{
        
        //注入JdbcTemplate
            @Autowired
            private JdbcTemplate jdbcTemplate;
        
            //添加的方法
            @Override
            public void add(Book book) {
        
                //1.创建sql语句
                String sql = "insert into book values(?,?,?)";
                //2.调用方法实现
                //update:影响的行数,即最终添加的行数
                Object[] args = {book.getUserId(), book.getUsername(), book.getUstatus()};
                int update = jdbcTemplate.update(sql,args);
                System.out.println(update);
            }
        }
        
  • 测试:

    public class TestBook {
    
        @Test
        public void test1(){
    
            ApplicationContext context =
                    new ClassPathXmlApplicationContext("bean1.xml");
    
            BookService bookService = context.getBean("bookService", BookService.class);
    
            Book book = new Book();
    
            book.setUserId("1");
    
            book.setUsername("java");
    
            book.setUstatus("a");
    
            bookService.addBook(book);
    
        }
    }
    
(2).修改和删除功能
//修改的方法
@Override
public void updateBook(Book book) {

    String sql = "update book set username=?,ustatus=? where userId=?";
    Object[] args = {book.getUsername(), book.getUstatus(),book.getUserId()};
    int update = jdbcTemplate.update(sql,args);
    System.out.println(update);
}
//删除的方法
@Override
public void delete(String id) {

    String sql = "delete from book where userId=?";
    int update = jdbcTemplate.update(sql,id);
    System.out.println(update);
}
@Test
public void test1(){

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

    BookService bookService = context.getBean("bookService", BookService.class);

    Book book = new Book();

    book.setUserId("1");

    book.setUsername("javaup");

    book.setUstatus("bbb");

    bookService.updateBook(book);

}
@Test
 public void test1(){

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

     BookService bookService = context.getBean("bookService", BookService.class);

     Book book = new Book();

     bookService.deleteBook("1");

 }
(3).查询功能
  • 查询返回某个值

    • 查询表里面有多少条记录,返回某个值

    • 使用JdbcTemplate实现查询返回某个值代码
      Spring5

      • 有两个参数

      • 第一个参数:sql语句

      • 第二个参数:返回类型.class

        //查询表记录数
        @Override
        public int selectCount() {
        
            String sql = "select count(*) from book";
        
            Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        
            return count;
        
        }
        
        测试:
         @Test
            public void test1(){
        
                ApplicationContext context =
                        new ClassPathXmlApplicationContext("bean1.xml");
        
                BookService bookService = context.getBean("bookService", BookService.class);
                
                //查询返回某个值
                int count = bookService.findCount();
                
                System.out.println(count);
        
            }
        

  • 查询返回对象

    • 场景:查询图书详情

    • 使用JdbcTemplate实现查询返回对象
      Spring5

      • 有三个参数

      • 第一个参数:sql语句

      • 第二个参数:RowMapper是接口,返回不同类型数据,使用这个接口的实现类完成数据封装

      • 第三个参数:sql语句值

        @Override
        public Book findBookInfo(String id) {
        
            String sql = "select * from book where userId=?";
        
            Book book = jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<Book>(Book.class),id);
        
            return book;
        
        }
        
        测试:
         @Test
            public void test1(){
        
                ApplicationContext context =
                        new ClassPathXmlApplicationContext("bean1.xml");
        
                BookService bookService = context.getBean("bookService", BookService.class);
                
                Book book = bookService.findOne("1");
                
                System.out.println(book);
        
            }
        
  • 查询返回集合

    • 场景:查询图书列表分页

    • 使用JdbcTemplate实现查询返回集合
      Spring5

      • 有三个参数

      • 第一个参数:sql语句

      • 第二个参数:RowMapper是接口,返回不同类型数据,使用这个接口的实现类完成数据封装

      • 第三个参数:sql语句值(没有可以不写)

        //查询返回集合
        @Override
        public List<Book> finAllBook() {
        
            String sql = "select * from book";
        
            List<Book> bookList = jdbcTemplate.query(sql,new BeanPropertyRowMapper<Book>(Book.class));
        
            return bookList;
        }
        
        @Test
        public void test1(){
        
            ApplicationContext context =
                    new ClassPathXmlApplicationContext("bean1.xml");
        
            BookService bookService = context.getBean("bookService", BookService.class);
        
            List<Book> all = bookService.findAll();
        
            System.out.println(all);
        
        }
        
(4).批量操做

操做表里面多条记录

  • 批量添加操做
    Spring5

    • 有两个参数

    • 第一个参数:sql语句

    • 第二个参数:添加多条记录的数据

      //批量添加
      @Override
      public void batchAddBook(List<Object[]> batchArgs) {
      
          String sql = "insert into book values(?,?,?)";
      
          int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
      
          System.out.println(Arrays.toString(ints));
      }
      
@Test
public void test1(){

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

    BookService bookService = context.getBean("bookService", BookService.class);

    List<Object[]> batchArgs = new ArrayList<>();

    Object[] o1 = {"3","javascript","c"};
    Object[] o2 = {"4","jsp","d"};
    Object[] o3 = {"5","jquery","e"};

    batchArgs.add(o1);
    batchArgs.add(o2);
    batchArgs.add(o3);

    bookService.batchAdd(batchArgs);

}
  • 批量修改操做

    //批量修改
    @Override
    public void batchUpdateBook(List<Object[]> batchArgs) {
    
        String sql = "update book set username=?,ustatus=? where userId=?";
    
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    
        System.out.println(Arrays.toString(ints));
    
    }
    
     @Test
        public void test1(){
    
            ApplicationContext context =
                    new ClassPathXmlApplicationContext("bean1.xml");
    
            BookService bookService = context.getBean("bookService", BookService.class);
    
            List<Object[]> batchArgs = new ArrayList<>();
    
            Object[] o1 = {"MySql","c1","3"};
            Object[] o2 = {"Linux","d1","4"};
            Object[] o3 = {"Spring","e1","5"};
    
            batchArgs.add(o1);
            batchArgs.add(o2);
            batchArgs.add(o3);
    
            bookService.batchUpdate(batchArgs);
    
       }
    
  • 批量删除操做

    //批量删除
    @Override
    public void batchDeleteBook(List<Object[]> batchArgs) {
    
        String sql = "delete from book where userId=?";
    
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    
        System.out.println(Arrays.toString(ints));
    }
    
 @Test
    public void test1(){

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

        BookService bookService = context.getBean("bookService", BookService.class);

        List<Object[]> batchArgs = new ArrayList<>();

        Object[] o1 = {"3"};
        Object[] o2 = {"4"};

        batchArgs.add(o1);
        batchArgs.add(o2);

        bookService.batchDelete(batchArgs);

   }

七.事务操做

1.事务概念

(1).什么是事务

  • 事务是数据库操做最基本单元,逻辑上一组操做,要么都成功,如果有一个失败所有操做都失败
  • 经典场景:银行转账
    • lucy转账100元给mary
    • lucy少100,mary多100

(2).事务四个特性(ACID)

  • 原子性:要么都成功,要么都失败
  • 一致性:虽然lucy少100,mary多100,但是他俩总和不变
  • 隔离性:多个事务同时操做的时候互不干扰
  • 持久性:当事务提交时,表中的数据才会真正改变

2.搭建事务操做环境

Spring5

(1).创建数据库表,添加记录

Spring5

(2).创建service,搭建dao,完成对象创建注入关系

service注入dao,在dao注入JdbcTemplate,在JdbcTemplate注入DataSource

@Service
public class UserService {

    //注入dao
    @Autowired
    private UserDao userDao;
}
@Repository
public class UserDaoImpl implements UserDao{

    //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;

}
<!--开启组件扫描-->
    <context:component-scan base-package="com"></context:component-scan>

<!--数据库连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">

        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
        <property name="username" value="root"></property>
        <property name="password" value="wwyyll123"></property>

    </bean>

<!--JdbcTemplate对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--注入datasource-->
    <property name="dataSource" ref="dataSource"></property>
</bean>

(3).在dao创建两个方法:多钱和少钱的方法,在service创建方法:转账的方法

@Repository
public class UserDaoImpl implements UserDao{

    @Autowired
    private JdbcTemplate jdbcTemplate;

    //少钱
    @Override
    public void reduceMoney() {

        String sql = "update account set money = money - ? where username = ?";

        jdbcTemplate.update(sql, 100, "lucy");

    }

    //多钱
    @Override
    public void addMoney() {

        String sql = "update account set money = money + ? where username = ?";

        jdbcTemplate.update(sql, 100, "mary");

    }

}
@Service
public class UserService {

    //注入dao
    @Autowired
    private UserDao userDao;

    //转账的方法
    public void accountMoney(){

        //lucy少100
        userDao.reduceMoney();

        //mary多100
        userDao.addMoney();

    }

}

测试:

@Test
public void testAccount(){

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

    UserService userService = context.getBean("userService",UserService.class);

    userService.accountMoney();

}

3.Spring事务管理介绍

(1).事务添加到JavaEE三层结构里面Service层(业务逻辑层)

(2).在Spring进行事务管理操做的两种方式

  • 编程式(一般不用,不作介绍)
  • 声明式(经常用)

(3).声明式事务管理

  • 基于注解方式(常用)
  • 基于xml配置文件方式(不常用)

(4).在Spring进行声明式事务管理,底层使用AOP原理

(5).Spring事务管理API

提供一个接口,代表事务管理器,这个接口针对不同的框架提供不同的实现类

Spring5

4.Spring声明式事务管理

(1).注解方式
  • 在Spring配置文件中配置事务管理器

    <!--创建事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    
          <!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    
    </bean>
    
  • 在Spring配置文件中开启事务注解

    • 在Spring配置文件中引入tx名称空间

      <?xml version="1.0" encoding="UTF-8"?>
      <beans xmlns="http://www.springframework.org/schema/beans"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns:context="http://www.springframework.org/schema/context"
             xmlns:tx="http://www.springframework.org/schema/tx"
             xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                                 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                                 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
          
      </beans>
      
    • 开启事务注解

      <!--开启事务注解-->
      <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
      
  • 在service类上面(或者service类里面的方法上面)添加事务注解

  • @Transactional

  • 如果把这个注解添加到上面,这个类里面的所有方法都添加事务

  • 如果把这个注解添加到方法上面,为这个方法添加事务

    @Service
    @Transactional
    public class UserService {
    
(2).事务参数
  • propagation:事务传播行为

    当一个事务的方法被另外一个事务的方法调用的时候,这个事务方法如何进行处理

    事务的传播行为可以由事务属性指定

Spring5

Spring5

Spring5

Spring5

执行方法A,会开启外层事务,执行方法B,就会开启内层事务,如果事务T1在执行过程中发生异常,不会影响事务T2的提交

Spring5

Spring5

如果执行方法A,就会开启事务A,方法B就会被加入到事务A,如果单独执行方法B,方法B在非事务中运行(不会开启事务B)

  • ioslation:事务隔离级别

    • 事务的隔离性,多事务操作间不会产生影响,不考虑隔离性会产生很多问题

    • 三个读问题:脏读,不可重复读,虚(幻)读

    • 脏读:一个未提交事务读取到另一个未提交事务的数据

Spring5

  • 不可重复读:一个未提交事务读取到另一个提交事务修改的数据

Spring5

  • 幻读:一个未提交事务读取到另一个提交事务添加的数据

  • 解决:通过设置事务隔离性,解决读问题

Spring5

    @Service
    @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)
    public class UserService {
  • 其他参数

    • timeout:超时时间

      • 事务需要在一定时间内进行提交,如果不提交进行回滚
      • 默认值是-1,设置时间以秒为单位进行
    • readOnly:是否只读

      • 读:查询,写:增删改

      • 默认值是false:表示可以进行增删改查

      • 设置值是true:表示只能查

    • rollbackFor:回滚

      • 设置出现哪些异常,进行回滚
    • noRollbackFor:不回滚

      • 设置出现哪些异常,不进行回滚
(3).xml配置文件方式

​ 在Spring配置文件中进行配置

​ 第一步,配置事务管理器

<!--1.创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

    <!--注入数据源-->
    <property name="dataSource" ref="dataSource"></property>

</bean>

​ 第二步,配置通知

<!--2.配置通知-->
 <tx:advice id="txadvice">
     <!--配置事务参数-->
     <tx:attributes>
         <!--指定哪种规则的方法上面添加事务-->
         <tx:method name="accountMoney" isolation="REPEATABLE_READ" propagation="REQUIRED" />
        <!-- <tx:method name="account*" /> -->
     </tx:attributes>
 </tx:advice>

​ 第三步,配置切入点和切面

<!--3.配置切入点和切面-->
<aop:config>

    <!--配置切入点-->
    <aop:pointcut id="pt" expression="execution(* com.service.UserService.*(..))"/>

    <!--配置切面-->
    <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
    
</aop:config>
(4).完全注解方式

使用配置类替代Spring配置文件文章来源地址https://www.toymoban.com/news/detail-481531.html

@Configuration//配置类
@ComponentScan(basePackages = "com")//组件扫描
@EnableTransactionManagement//开启事务
public class TxConfig {

//创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource(){

        DruidDataSource dataSource = new DruidDataSource();

        dataSource.setDriverClassName("com.mysql.jdbc.Driver");

        dataSource.setUrl("jdbc:mysql://localhost:3306/userDb");

        dataSource.setUsername("root");

        dataSource.setPassword("wwyyll123");

        return dataSource;

    }

    //创建JdbcTemplate对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DruidDataSource dataSource){

        JdbcTemplate jdbcTemplate = new JdbcTemplate();

        //注入datasource
        jdbcTemplate.setDataSource(dataSource);

        return jdbcTemplate;

    }

    //创建事务管理器对象
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DruidDataSource dataSource){

        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();

        //注入datasource
        transactionManager.setDataSource(dataSource);

        return transactionManager;

    }

}
@Test
public void testAccount2(){

    ApplicationContext context =
            new AnnotationConfigApplicationContext(TxConfig.class);

    UserService userService = context.getBean("userService",UserService.class);

    userService.accountMoney();

}

到了这里,关于Spring5的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 使用Go语言打造轻量级Web框架

    前言 Web框架是Web开发中不可或缺的组件。它们的主要目标是抽象出HTTP请求和响应的细节,使开发人员可以更专注于业务逻辑的实现。在本篇文章中,我们将使用Go语言实现一个简单的Web框架,类似于Gin框架。 功能 我们的Web框架需要实现以下功能: 路由:处理HTTP请求的路由

    2023年04月08日
    浏览(52)
  • 互联网轻量级框架整合之设计模式

    Java的反射技术能够通过配置类的全限定名、方法和参数完成对象的初始化,甚至反射某些方法,大大的增强了Java的可配置型,这也是Spring IoC的底层原理,Java的反射技术覆盖面很广,包括对象构建、反射方法、注解、参数、接口等等,而这一切都是通过 java.lang.reflect.* 来完成

    2024年04月11日
    浏览(72)
  • Forest-极简的轻量级HTTP调用API框架

    是不是一想到要对接第三方系统接口就发愁,尤其是与其他系统有大量接口交互时,不得不应对各种请求方式、设置各种不同的头、不同的返回、需要权限或token验证等等,将头疼不已,即使有Httpclient似乎还是要写很多的代码,那么Forest将解决你这一烦恼。 Forest是专注于简化

    2024年02月06日
    浏览(48)
  • 【KRouter】一个简单且轻量级的Kotlin Routing框架

    KRouter(Kotlin-Router)是一个简单而轻量级的Kotlin路由框架。 具体来说,KRouter是一个通过URI来发现接口实现类的框架。它的使用方式如下: 之所以这样做,是因为在使用Voyager一段时间后,我发现模块之间的通信不够灵活,需要一些配置,而且使用DeepLink有点奇怪,所以我更喜

    2024年02月09日
    浏览(87)
  • 初识Flask:Python轻量级Web框架入门教程

    Flask是一个用Python编写的轻量级Web应用框架。由于其“微”性质,Flask在提供核心服务的同时,仍然提供了许多扩展的可能性。在这篇文章中,我们将从最基础开始,学习如何使用Flask构建一个Web应用。 首先,你需要安装Flask库。使用pip进行安装是最简单的方式: 接着,我们来

    2024年02月14日
    浏览(90)
  • deepface:最先进轻量级人脸识别和人脸属性分析框架讲解

    Deepface 是一个用于 python 的轻量级人脸识别和人脸属性分析(年龄、性别、情感和种族)框架。它是一个混合人脸识别框架。 deepface包含最先进的模型:VGG-Face、Google FaceNet、OpenFace、Facebook DeepFace和DeepIDArcFaceDlib。所有这些模型都封装在一起,Deepface 的人脸识别准确率高达 97

    2024年02月04日
    浏览(36)
  • 架构:Oracle推出开源轻量级Java微服务框架Helidon

    在当今数字化时代,微服务架构已经成为构建灵活、可伸缩和高度可维护的应用程序的首选方式之一。Java一直以其稳定性和跨平台性而闻名,而Oracle则一直是Java的领先开发者之一。为了满足不断增长的微服务市场需求,Oracle于近年推出了开源的轻量级Java微服务框架Helidon,为

    2024年02月02日
    浏览(51)
  • Linux下C++轻量级WebServer服务器 框架梳理

    WebServer是一个很好的入门级C++项目,因为它涉及到了方方面面,不仅可以提高编程能力,还包括了操作系统、计算机网络、数据库等方面的知识,所以我很推荐大家去入手这个项目。说细一点这个项目包含系统编程、日志系统、线程池、网络知识、并发模型等实现,但是很多

    2024年03月15日
    浏览(77)
  • Spring Boot整合Postgres实现轻量级全文搜索

    有这样一个带有搜索功能的用户界面需求: 搜索流程如下所示: 这个需求涉及两个实体: “评分(Rating)、用户名(Username)”数据与 User 实体相关 “创建日期(create date)、观看次数(number of views)、标题(title)、正文(body)”与 Story 实体相关 需要支持的功能对 User

    2024年02月19日
    浏览(42)
  • 轻量级web开发框架:Flask本地部署及实现公网访问界面

    本篇文章讲解如何在本地安装Flask,以及如何将其web界面发布到公网上并进行远程访问。 Flask是目前十分流行的web框架,采用Python编程语言来实现相关功能。较其他同类型框架更为灵活、轻便、安全且容易上手。它可以很好地结合MVC模式进行开发,开发人员分工合作,小型团

    2024年02月05日
    浏览(61)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包