Spring5

最新推荐文章于 2024-08-08 14:30:51 发布
最新推荐文章于 2024-08-08 14:30:51 发布
阅读量734 收藏 1
点赞数
分类专栏： SSM 文章标签： java spring SSM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53798578/article/details/131037913
版权

Spring5

文章目录

一.框架概述

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

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

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

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

3.Spring的两个核心部分分别是:IOC和AOP

(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解析

  • 工厂模式

  • 反射

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

3.IOC接口

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

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

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

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

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

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

(3).ApplicationContext接口实现类

在这里插入图片描述

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实例

创建对象

第一步,引入依赖

在这里插入图片描述

第二步,开启组件扫描

告诉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动态代理

在这里插入图片描述

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

在这里插入图片描述

(2).JDK动态代理实现

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

在这里插入图片描述

此方法有三个参数:

第一个参数,类加载器

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

第三个参数,实现这个接口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框架,一般把AspectJ和Spring框架一起使用,进行AOP操做

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

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

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

在这里插入图片描述

(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包

在这里插入图片描述

  • 在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方法实现添加操做
      在这里插入图片描述

      • 有两个参数

      • 第一个参数: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实现查询返回某个值代码
      在这里插入图片描述

      • 有两个参数

      • 第一个参数: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实现查询返回对象
      在这里插入图片描述

      • 有三个参数

      • 第一个参数: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实现查询返回集合
      在这里插入图片描述

      • 有三个参数

      • 第一个参数: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).批量操做

操做表里面多条记录

  • 批量添加操做
    在这里插入图片描述

    • 有两个参数

    • 第一个参数: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.搭建事务操做环境

在这里插入图片描述

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

在这里插入图片描述

(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

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

在这里插入图片描述

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:事务传播行为

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

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

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

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

在这里插入图片描述

在这里插入图片描述

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

  • ioslation:事务隔离级别

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

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

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

在这里插入图片描述

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

在这里插入图片描述

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

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

在这里插入图片描述

    @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配置文件

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

}
懒羊羊asd
关注
专栏目录
Spring5.pdf
03-19
Spring5
Spring5jar包 完整版下载
03-05
Spring5是中国Java开发者广泛使用的开源框架，主要用于构建企业级应用。这个"Spring5jar包 完整版下载"提供的是Spring框架的第五个主要版本，它包含了一系列的类库，覆盖了Spring的核心特性以及与其他技术的集成。让...
Spring5.zip
08-02
Spring运行helloworld所需的三个基础包，分明为com.springsource.org.apache.commons.logging-1.1.1.jar，spring-beans-5.0.2.RELEASE.jar,spring-core-5.0.2.RELEASE.jar
Mastering Spring 5: 2nd Edition
09-03
Mastering Spring 5 starts with an overview of some of the important Spring Framework features relating to aspect-oriented programming, task scheduling, and scripting with the help of practical ...
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 515
使用TCP协议支持与多个客户端同时通信。
C++ - 函数重载
jiaowenjie的专栏
08-06 280
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 1345
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
枚举工具类
qq_43049583的博客
08-04 504
java枚举工具类
时光不等人：java每日一练
m0_67187271的博客
08-05 1051
时光悄然流逝，不等人。技术亦不会自来门前，唯有勤奋学习，方能抓住时代的脉搏。
等待唤醒机制两种实现方法-阻塞队列
泰勒今天想展开的博客
08-04 579
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
Servlet(2)
xjdkxnhcoskxbco的博客
08-04 801
这个注解可以用来修饰一个Servlet类，可以简化配置，替代Web.xml中 的servlet配置。
Spring事务
c1tenj2的博客
08-07 386
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
【SpringBoot】数据验证之分组校验
Jacker
08-05 366
下面通过示例演示分组校验。在上面的示例中，在@Validated注解中增加了{GroupA.class,Default.class}参数，表示对于定义了分组校验的字段使用GroupA校验规则，其他字段使用默认规则。@Length(min=20,max=30,message="必须在[20,30]")，groups={GroupA.class};@Length(min=30,max=40,message="必须在[30,40]",groups={GroupB.class})/**用户id**/
在java java.util.Date 已知逝去时间怎么求年月日
huanghm88的专栏
08-05 333
这样，你就可以得到逝去时间的年月日。需要注意的是，这只是一个简单的方法，不考虑闰年等情况。如果你需要更准确的结果，可以使用其他时间处理库，如Joda-Time或java.time包。
反射和注解
最新发布
supercool7的博客
08-08 178
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
linux安装weblogic
m0_46400195的博客
08-05 827
域文件位置就是python文件中设置的，位置（cd /root/web/weblogic/softWare/projects/doamins/testDomain）（以自己python为主）想要启动weblogic 12版本及以后都需要去oracle_common目录下配合启动脚本进行服务器启动。weblogic不允许root用户进行安装，所以要提前创建weblogic用户来进行安装。例如：http://192.168.0.143:7001/console。用户名：启动weblogic的用户名。
Java | Leetcode Java题解之第324题摆动排序II
m0_57195758的博客
08-06 319
Java | Leetcode Java题解之第324题摆动排序II
Java 设计模式之桥接模式（Bridge Pattern）
微笑听雨
08-05 1381
桥接模式（Bridge Pattern）是一种用于将抽象部分与其实现部分分离的结构型设计模式。这种模式通过组合关系而不是继承关系来连接抽象与实现，使代码更具扩展性和维护性。桥接模式的核心思想是将抽象和实现解耦，使得两者可以独立变化。桥接模式（Bridge Pattern）是一种结构型设计模式，旨在将抽象部分与其实现部分分离，从而使两者可以独立地变化。桥接模式通过组合关系代替继承关系，将抽象和实现解耦，使代码更具扩展性和维护性。
深入理解Spring 5设计模式
"Spring 5 Design Patterns 是一本关于Spring框架第五版的设计模式指南，由Dinesh Chalasani撰写，由Packt Publishing出版。本书旨在深入探讨在Spring 5中如何应用各种设计模式，以提升软件开发的效率和可维护性。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值