Spring学习笔记（完结）

于 2022-08-04 10:33:34 发布
阅读量144 收藏
点赞数
文章标签： spring 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52798101/article/details/126154726
版权

💕目录在左侧或者右侧哦，下面是正文💕
.
.

Spring

简介

  • Rod Johnson，Spring Framework创始人，著名作者。很难想象Rod Johnson的学历，真的让好多人大吃一惊，他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。

官网：https://spring.io/projects/spring-framework#overview
官方下载地址：https://repo.spring.io/release/org/springframework/spring/
GitHub：https://github.com/spring-projects/spring-framework

优点

  • Spring是一个开源的免费的框架（容器）
  • spring是一个轻量级的、非入侵式的框架
  • 控制反转（Ioc）、面向切面编程（aop）
  • 支持事务的处理，对框架整合的支持

组成

img

核心容器（Spring Core）

核心容器提供Spring框架的基本功能。Spring以bean的方式组织和管理Java应用中的各个组件及其关系。Spring使用BeanFactory来产生和管理Bean，它是工厂模式的实现。BeanFactory使用控制反转(IoC)模式将应用的配置和依赖性规范与实际的应用程序代码分开。

应用上下文（Spring Context）

Spring上下文是一个配置文件，向Spring框架提供上下文信息。Spring上下文包括企业服务，如JNDI、EJB、电子邮件、国际化、校验和调度功能。

Spring面向切面编程（Spring AOP）

通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring框架中。所以，可以很容易地使 Spring框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。

JDBC和DAO模块（Spring DAO）

JDBC、DAO的抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理，和不同数据库供应商所抛出的错误信息。异常层次结构简化了错误处理，并且极大的降低了需要编写的代码数量，比如打开和关闭链接。

对象实体映射（Spring ORM）

Spring框架插入了若干个ORM框架，从而提供了ORM对象的关系工具，其中包括了Hibernate、JDO和 IBatis SQL Map等，所有这些都遵从Spring的通用事物和DAO异常层次结构。

Web模块（Spring Web）

Web上下文模块建立在应用程序上下文模块之上，为基于web的应用程序提供了上下文。所以Spring框架支持与Struts集成，web模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

MVC模块（Spring Web MVC）

MVC框架是一个全功能的构建Web应用程序的MVC实现。通过策略接口，MVC框架变成为高度可配置的。MVC容纳了大量视图技术，其中包括JSP、POI等，模型来有JavaBean来构成，存放于m当中，而视图是一个街口，负责实现模型，控制器表示逻辑代码，由c的事情。Spring框架的功能可以用在任何J2EE服务器当中，大多数功能也适用于不受管理的环境。Spring的核心要点就是支持不绑定到特定J2EE服务的可重用业务和数据的访问的对象，毫无疑问这样的对象可以在不同的J2EE环境，独立应用程序和测试环境之间重用。

依赖导包

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

IOC理论推导

创建一个普通的maven项目，导入spring的依赖，在pom.xml中

  1. UserDao接口

    package com.blue.dao;

public interface UserDao {
    void getUser();
    }

  2. UserDaolmpl实现类

    package com.blue.dao;

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

  3. UserService业务接☐

    package com.blue.service;

public interface UserService {
    void getUser();
}

  4. UserServicelmpl业务实现类

    package com.blue.service;

import com.blue.dao.UserDao;
import com.blue.dao.UserDaoImpl;

public class UserServiceImpl implements UserService{

    private UserDao userDao = new UserDaoImpl();

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

  5. MyTest测试

package com.blue.dao;

import com.blue.service.UserService;
import com.blue.service.UserServiceImpl;

public class MyTest {
    public static void main(String[] args) {

        ///用户实际调用的是业务层，dao层他们不需要接触！
        UserService userService = new UserServiceImpl();

        userService.getUser();

    }
}
  1. 如果要加入多几个其他的业务

UserDaoMysqlImpl.java

package com.blue.dao;

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

如果要使用这个业务，就要修改：UserServicelmpl业务实现类里面的代码，

    private UserDao userDao = new UserDaoImpl();
    把这一行改为
    private UserDao userDao = new UserDaoMysqlImpl();

这样如果有很多行，这种语句，就要修改很多地方

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

  • 之前，程序是主动创建对象！控制权在程序猿手上！
  • 使用了set注入后，程序不再具有主动性，而是变成了被动的接受对象！

在UserServicelmpl中加入：

//利用set进行动态实现值的注入
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

这种思想，从本质上解决了问题，我们程序猿不用再去管理对象的创建了。系统的耦合性大大降低，可以更加专注的在业务的实现上！这是IOC的原型！

MyTest测试

package com.blue.dao;

import com.blue.service.UserService;
import com.blue.service.UserServiceImpl;

public class MyTest {
    public static void main(String[] args) {

        ///用户实际调用的是业务层，dao层他们不需要接触！
        UserServiceImpl userService = new UserServiceImpl();

        userService.setUserDao(new UserDaoMysqlImpl());
        userService.getUser();

    }
}

IOC本质控制反转

**IoC(Inversion of Control),是一种设计思想，DI(依赖注入)是实现Ioc的一种方法，**也有人认为DI只是 IoC 的另一种说法。没有引 ioC 的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入(Dependency Injection,Dl)。

第一个spring

根据上面的ioc理论推导的代码，修改一下；

在resources文件夹下创建beans.xml

前提是UserServiceImpl中有set方法

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--使用Spring来创建对象，在Spring这些都称为Bean
    id = 变量名
    class = new的对象
    property 相当于给对象中的属性设置一个值！
        -->
    <bean id="mysql" class="com.edu.dao.UserDaoMysqlImpl"/>
    <bean id="origal" class="com.edu.dao.UserDaoImpl"/>

    <bean id="UserServiceImpl" class="com.edu.service.UserServiceImpl">
        <property name="userDao" ref="mysql"/>
    </bean>
</beans>

MyTest

import com.edu.service.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author 我
 * @version 1.0
 */
public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserServiceImpl userServiceImpl =(UserServiceImpl) context.getBean("UserServiceImpl");
        userServiceImpl.getUser();
    }
}

IOC创建对象的方式

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

        <bean id="user" class="com.kuang.pojo.User">
        <property name="name" value="houmou"/>
    </bean>

  2. 使用有参构造

下标赋值

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

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

类型赋值（不建议使用）

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

直接通过参数名

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

Spring类似于婚介网站！

你想不想要，对象都在里面。注册bean之后用不用被实例化。

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了！你想用哪个调用哪个就可以

spring配置

取别名

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

<alias name="user" alias="user2aaa"/>

bean配置

​ id：bean的唯一标识符，也就是相当于我们学的对象名
​ class：bean对象所对应的全限定名：包名+类名
​ name：也是别名，而且name可以同时取多个别名

    <bean id="userT" class="com.kuang.pojo.UserT" name="user2 u2,u3;u4">
        <property name="name" value="狂神"/>
    </bean>

import

这个import。一般用于团队开发使用，它可以将多个配置文件，导入合并为一个。
假设，现在项目中有多个人开发，这三个人负责不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的！

张三
李四
王五
applicationContext.xml

<import resource="bean.xml"/>
<import resource="bean2.xml"/>
<import resource="bean3.xml"/>

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

依赖注入

依赖注入简单来说就是给类中的属性赋值。

1. 构造器注入

前面在 ioc创建对象方式 那里已经写过了

2. Set方式注入【重点】

依赖注入：Set注入

  • 依赖：bean对象的创建依赖于容器。
  • 注入：bean对象中的所有属性，由容器来注入。

【环境搭建】

  1. 复杂类型
  2. 真实测试对象
package com.pojo;

import java.util.*;

public class Student {

    private String name;
    private Address address;

    private String[] books;
    private List<String> hobbies;

    private Map<String, String> card;
    private Set<String> game;

    private Properties infor;
    private String wife;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address +
                ", books=" + Arrays.toString(books) +
                ", hobbies=" + hobbies +
                ", card=" + card +
                ", game=" + game +
                ", infor=" + infor +
                ", wife='" + wife + '\'' +
                '}';
    }
}



    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

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

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

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

    <bean id="student" class="com.pojo.Student">
        <property name="name" value="hou"/>
        <property name="address" ref="address"/>

        <!--数组注入-->
        <property name="books">
            <array>
                <value>三国</value>
                <value>西游</value>
                <value>水浒</value>
            </array>
        </property>

        <!--list-->
        <property name="hobbies">
            <list>
                <value>eat</value>
                <value>drink</value>
                <value>play</value>
            </list>
        </property>

        <property name="card">
            <map>
                <entry key="1" value="12"/>
                <entry key="2" value="23"/>
            </map>
        </property>

        <property name="game">
            <set>
                <value>wangzhe</value>
                <value>daota</value>
                <value>lol</value>
            </set>
        </property>

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

        <!--properties-->
        <property name="infor">
            <props>
                <prop key="id">20200405</prop>
                <prop key="name">hdk</prop>
            </props>
        </property>
    </bean>

</beans>

3. p标签注入和c标签注入

在beans.xml中加入

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

实体类：

package com.pojo;

public class User {

    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

beans.xml

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

    <!--p命名空间注入/set注入-->
    <bean id="use" class="com.pojo.User" p:name="dong" p:age="10">
    </bean>

    <!--c命名空间/构造器-->
    <bean id="use2" class="com.pojo.User" c:name="kun" c:age="19"></bean>
</beans>

bean的作用域

在这里插入图片描述

单例模式(singleton)（Spring默认机制）

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

ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
        User user1 = context.getBean("user2", User.class);
        User user2 = context.getBean("user2", User.class);
        System.out.println(user1 == user2); //ture

原型模式(prototype)：每次从容器中get的时候，都会产生一个新的对象。

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

   ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
        User user1 = context.getBean("user2", User.class);
        User user2 = context.getBean("user2", User.class);
        System.out.println(user1 == user2); //false

其余的request、session、application，这些只能在web开发中使用到。

Bean的自动装配

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

在Spring中有三种装配的方式：

  1. 在xml中显式的配置。
  2. 在java中显示配置。
  3. 隐式的自动装配bean【重要】。

环境搭建：一个人有两个宠物。

public class Cat {
    public void shout(){
        System.out.println("猫叫");
    }
}


public class Dog {
    public void shout(){
        System.out.println("狗叫");
    }
}


public class People {
    private Cat cat;
    private Dog dog;
    private String name;
    
    get和set方法、toString方法省略
}

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

ByName自动装配

byName:会自动在容器上下文中查找，和自己对象set方法后面的值对应的bean id ，且bean的id唯一。

即 setCat() ，那么id=“cat” ,如果是id="cat111"就会报错

beans.xml修改如下：

<bean id="cat" class="com.kuang.pojo.Cat"/>
<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="people" class="com.kuang.pojo.People" autowire="byName">
            <property name="name" value="狂神"/>
</bean>

ByType自动装配

byType:会自动在容器上下文中查找，和自己对象属性类型相同的bean，需要保证属性类型（bean的class唯一）全局唯一 。

如果不唯一的话，会报错。即：如果有两个bean中有 class="com.kuang.pojo.Dog 就会报错

beans.xml修改如下：

<bean id="cat" class="com.kuang.pojo.Cat"/>
<bean id="dog" class="com.kuang.pojo.Dog"/>  
<bean id="people" class="com.kuang.pojo.People" autowire="byType">
            <property name="name" value="狂神"/>
</bean>

使用注解实现自动装配

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

要使用注解须知：

  1. 导入约束（ xmlns:context=“http://www.springframework.org/schema/context”

    https://www.springframework.org/schema/context/spring-context.xsd

    如果要导入aop也是一样的，把context换成aop即可

    ）

  2. 配置注解的支持（context:annotation-config/）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   1.    xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
	     https://www.springframework.org/schema/beans/spring-beans.xsd
	  1. http://www.springframework.org/schema/context
	      https://www.springframework.org/schema/context/spring-context.xsd">
		
		<!--开启注解的支持    -->
       2. <context:annotation-config/>
</beans>

@Nullable

@Nullable 字段标记了了这个注解，说明这个字段可以为null;

例子：

public void test(@Nullable String name){
.....
}

@Autowired

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

使用Autowired我们就可以不用编写set方法了，前提是你这个自动配置的属性在IOC（Spring）容器中存在，且符合名字ByName！

总结：

  1. Autowired默认通过byType的方式实现，如果有两个bytype，则如果有id= cat那么也可以。

  2. 如果既有两个bytype,而且id没有等于cat的，就需要用到@Qualifier（value = …）

  3. 如果既有两个bytype，同时有两个id都为cat，那么就会报错。

beans.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
    <!--开启注解的支持    -->
    <context:annotation-config/>
    
    <bean id="cat" class="com.edu.pojo.Cat"/>
    <bean id="cat3" class="com.edu.pojo.Cat"/>
    <bean id="dog" class="com.edu.pojo.Dog"/>
    <bean id="people" class="com.edu.pojo.People"/>
</beans>

如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以使用@Qualifier(value = “xxx”)去配置@Autowired的使用，指定一个唯一的bean对象注入！

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

如果显式定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空

public class People {
    @Autowired(required = false)
    private Cat cat;
    @Autowired
    private Dog dog;
    private String name;
}

@Resource

Resource默认通过byName的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！

public class People {

    @Resource
    private Cat cat;

    @Resource
    private Dog dog;
}

小结：

@Resource和@Autowired的区别：

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

使用注解开发

在Spring4之后，要使用注解开发，必须要保证aop的包导入了

或者直接导入

 <dependency>     <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.16</version>
        </dependency>

使用注解需要

  1. 导入约束
  2. 配置注解的支持！
<?xml version="1.0" encoding="UTF-8"?>
	<beans xmlns="http://www.springframework.org/schema/beans"
	       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	       xmlns:context="http://www.springframework.org/schema/context"
	       xsi:schemaLocation="http://www.springframework.org/schema/beans
		        https://www.springframework.org/schema/beans/spring-beans.xsd
		        http://www.springframework.org/schema/context
		        https://www.springframework.org/schema/context/spring-context.xsd">
			
   <!--指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.kuang"
			<!--开启注解的支持    -->
	        <context:annotation-config/>
	        
</beans>

属性如何注入

//等价于<bean id="user" class="com.kuang.pojo.User"/>
@Component
public class User {
    //相当于  <property name="name" value="白莲"/>
    @Value("白莲")
    public String name;
}

衍生的注解

@Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层！

dao 【@Repository】

service 【@Service】

controller 【@Controller】

这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean

作用域

@Scope(“singleton”)

总结

xml与注解：
xml更加万能，适用于任何场合！维护简单方便
注解维护相队复杂！
xml与注解最佳实践：
xml用来管理bean；
注解只负责完成属性的注入；
我们在使用的过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持

 <!--指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.kuang"/>
    <!--开启注解的支持    -->
    <context:annotation-config/>

使用Java的方式配置Spring

这个完全不需要使用Spring的xml配置了，全权交给Java来做。

JavaConfig是Spring的一个子项目，在Spring4之后，它成为了一个核心功能！

在这里插入图片描述

实体类，放在pojo的包下面

在实体类上方加入@Component，就是说明这个类被Spring接管了，注册到了容器中


@Component
public class User {
    private String name;

    public String getName() {
        return name;
    }

    @Value("黑心白莲") //属性注入值
    public void setName(String name) {
        this.name = name;
    }

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

配置文件类，放到config包下面

  • @Configuration：代表这是一个配置类，就和我们之前看的beans.xml，这个也会Spring容器托管，注册到容器中，因为它本来就是一个@Component
  • @ComponentScan(“com.kuang.pojo”)，扫描
  • @Import(KuangConfig2.class)，把ing一个配置文件的类导入
  • @Bean：注册一个bean，就相当于我们之前写的一个bean标签
@Configuration
@ComponentScan("com.kuang.pojo")
@Import(KuangConfig2.class)
public class KuangConfig {
    // 这个方法的名字，就相当于bean标签中id属性
    // 这个方法的返回值，就相当于bean标签中的class属性
    @Bean
    public User user(){
        return new User(); // 就是返回要注入到bean的对象！
    }
}

测试类

如果完全使用了配置类方式去做，我们就只能通过 AnnotationConfig 上下文来获取容器，通过配置类的class对象加载！

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(KuangConfig.class);

        User user = context.getBean("user", User.class);
        System.out.println(user.getName());
    }
}

这种纯Java的配置方式，在SpringBoot中随处可见！

代理模式

为什么要学习代理模式？因为代理模式是SpringAOP的底层！

代理模式的分类：

  • 静态代理
  • 动态代理

在这里插入图片描述

静态代理

角色分析：

  • 抽象角色：一般会使用接口或者抽象类来解决
  • 真实角色：被代理的角色
  • 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
  • 客户：访问代理对象的人！

代码步骤：

  1. 接口

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

  2. 真实角色

    //房东
public class Host implements Rent{
    public void rent() {
        System.out.println("房东出租房子！");
    }
}

  3. 代理角色

    public class Proxy implements Rent{
    private Host host;

    public Proxy() {
    }

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

    public void rent() {
        host.rent();
        seeHouse();
        sign();
        fee();
    }

    //看房
    public void seeHouse(){
        System.out.println("中介带着看房子！");
    }

    //签合同
    public void sign(){
        System.out.println("和中介签署租赁合同！");
    }

    //收费用
    public void fee(){
        System.out.println("中介收取费用！");
    }
}

  4. 客户端访问代理角色

    public class Client {
    public static void main(String[] args) {
        //房东要出租房子
        Host host = new Host();
//        host.rent();

        //代理，中介帮房东出租房子，并且代理角色一般会有一些附属操作！
        Proxy proxy = new Proxy(host);

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

    代理模式的好处：

  • 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
  • 公共角色就交给代理角色！实现了业务的分工！
  • 公共业务发生扩展的时候，方便集中管理！

缺点：

  • 一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低~

加深理解代理模式

代码步骤：

  1. 接口

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

  2. 真实角色

    //真实角色
public class UserServiceImpl implements UserService{
    public void add() {
        System.out.println("增加了一个用户！");
    }

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

    public void update() {
        System.out.println("修改了一个用户！");
    }

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

  3. 代理角色

    public class UserServiceProxy implements UserService{
    private UserServiceImpl userService;

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

    public void add() {
        log("add");
        userService.add();
    }

    public void delete() {
        log("delete");
        userService.delete();
    }

    public void update() {
        log("update");
        userService.update();
    }

    public void query() {
        log("query");
        userService.query();
    }

    public void log(String msg){
        System.out.println("[Debug] 使用了一个"+msg+"方法");
    }
}

  4. 客户端访问代理角色

    public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();

        UserServiceProxy proxy = new UserServiceProxy();
        proxy.setUserService(userService);

        proxy.delete();
    }
}

聊聊AOP

在这里插入图片描述

动态代理

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

  • 动态代理的代理类是动态生成的，不是我们直接写好的！

  • 动态代理分为两大类：基于接口的动态代理，基于类的动态代理

    • 基于接口 — JDK动态代理【我们在这里使用】

    • 基于类：cglib

    • java字节码实现：javassist

需要了解两个类：Proxy：代理；InvocationHandler：调用处理程序。

代码步骤：

  1. 接口
public interface Rent {
    public void rent();
}
  1. 真实角色
public class Host implements Rent{
    public void rent() {
        System.out.println("房东要出租房子！");
    }
}
  1. ProxyInvocationHandler类
//我们会用这个类，自动生成代理类！
public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Rent rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }

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

    //处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质，就是使用反射机制实现！
        Object result = method.invoke(rent, args);
        seeHose();
        fee();
        return result;
    }

    public void seeHose(){
        System.out.println("中介带着看房子！");
    }

    public void fee(){
        System.out.println("中介收取费用！");
    }
}

在此，我们可以提炼出ProxyInvocationHandler作为工具类

//用这个类自动生成代理类！
public class ProxyInvocationHandler implements InvocationHandler {

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

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

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

    //处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         
        //日志
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }
    
    //日志
     public void log(String msg){
        System.out.println("[Debug] 使用了一个"+msg+"方法");
        }
}

动态代理的好处：

  • 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
  • 公共角色就交给代理角色！实现了业务的分工！
  • 公共业务发生扩展的时候，方便集中管理！
  • 一个动态代理类代理的是一个接口，一般就是对应的一类业务
  • 一个动态代理类可以代理多个类，只要是实现了同一个接口即可！

aop

什么是AOP

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

在这里插入图片描述

AOP在Spring中的作用

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

img

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice：

在这里插入图片描述

在这里插入图片描述

即AOP在不改变原有代码的情况下，去增加新的功能。

使用Spring实现AOP

【重点】使用AOP织入，需要导入一个依赖包！

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

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

  1. 在service包下，定义UserService业务接口和UserServiceImpl实现类
public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();
}

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

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

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

    public void select() {
        System.out.println("查询了一个用户！");
    }
}
  1. 在log包下，定义我们的增强类，一个Log前置增强和一个AfterLog后置增强类
public class Log implements MethodBeforeAdvice {

    //method: 要执行的目标对象的方法
    //args：参数
    //target：目标对象
    public void before(Method method, Object[] agrs, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}

public class AfterLog implements AfterReturningAdvice {

    //returnValue： 返回值
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);
    }
}
  1. 最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束，配置applicationContext.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--注册bean-->
    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
    <bean id="log" class="com.kuang.log.Log"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>

    <!--方式一：使用原生Spring API接口-->
    <!--配置aop:需要导入aop的约束-->
    <aop:config>
        <!--切入点：expression：表达式，execution(要执行的位置！* * * * *)-->
        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>

        <!--执行环绕增加！-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>
  1. 测试
public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        //动态代理代理的是接口：注意点
        UserService userService = (UserService) context.getBean("userService");

        userService.add();
//        userService.select();
    }
}

方式二： 自定义类来实现AOP【主要是切面定义】

  1. 在diy包下定义自己的DiyPointCut切入类
public class DiyPointCut {
    public void before(){
        System.out.println("======方法执行前======");
    }

    public void after(){
        System.out.println("======方法执行后======");
    }
}
  1. 去spring中配置文件
  <!--方式二：自定义类-->
    <bean id="diy" class="com.kuang.diy.DiyPointCut"/>

    <aop:config>
        <!--自定义切面，ref 要引用的类-->
        <aop:aspect ref="diy">
            <!--切入点-->
            <aop:pointcut id="point" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>
  1. 测试，同上

方式三： 使用注解实现！

  1. 在diy包下定义注解实现的AnnotationPointCut增强类
  2. 导包时不要导错了[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dgHnUsO2-1659580152401)(D:\myDownloads\typora\img\image-20220803190721869.png)]
//声明式事务！
@Aspect //标注这个类是一个切面
public class AnnotationPointCut {

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

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

    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点；
    @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable{
        System.out.println("环绕前");

        Signature signature = jp.getSignature();// 获得签名
        System.out.println("signature:"+signature);

        Object proceed = jp.proceed(); //执行方法

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

        System.out.println(proceed);
    }

}
  1. 在Spring配置文件中，注册bean，并增加支持注解的配置。
  2. 开启注解支持！ JDK(默认是 proxy-target-class=“false”) cglib（proxy-target- class=“true”）
    <!--方式三：使用注解-->
    <bean id="annotationPointCut" class="com.kuang.diy.AnnotationPointCut"/>
   
    <aop:aspectj-autoproxy   proxy-target-class="false" />

  1. 结果

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RUdnawFy-1659580152404)(D:\myDownloads\typora\img\image-20220803191222265.png)]

环绕后 是在方法执行后的前面

整合Mybatis

需要导入相关的jar包

junit、mybatis、mysql数据库、spring相关的、aop植入、mybatis-spring

<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.16</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.2</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

Mybatis-Spring

什么是MyBatis-Spring？

MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。

文档链接：http://mybatis.org/spring/zh/index.html

整合实现方式一

  1. 创建项目

    com.edu.pojo

    User.class

    package com.edu.pojo;

import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;

/**
 * @author 我
 * @version 1.0
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private String pwd;
}

    com.edu.mapper包下：创建

    UserMapper接口

    package com.edu.mapper;

import com.edu.pojo.User;

import java.util.List;

/**
 * @author 我
 * @version 1.0
 */
public interface UserMapper {
    public List<User> selectUser();
}

    UserMapper.xml

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

<!--namespace=绑定一个指定的Dao/Mapper接口-->
<mapper namespace="com.edu.mapper.UserMapper">
    <select id="selectUser" resultType="user">
        select * from user
    </select>
</mapper>

    UserMapperImpl.xml

    package com.edu.mapper;

import com.edu.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;

import java.util.List;

/**
 * @author 我
 * @version 1.0
 */
public class UserMapperImpl implements UserMapper{

    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    @Override
    public List<User> selectUser() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

  2. 在resource 文件夹下创建：spring-dao.xml

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

    <!--    第一步：配置数据源替换mybatis的数据源-->

    <!--DataSource: 使用spring的数据源替换mybatis的配置
        此处使用spring提供的jdbc：org.springframework.jdbc.datasource-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

    <!--    第二步：配置SqlSessionFactory，关联Mybatis-->

    <!--sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--绑定Mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/edu/mapper/*.xml"/>
    </bean>

    <!--    第三步：注册sqlSessionTemplate，关联sqlSessionFactory-->

    <!--SqlSessionTemplate: 就是我们使用的sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入sqlSessionFactory,因为其没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>


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

</beans>

  1. 在resources下创建：mybatis-config.xml

    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration core file-->
<configuration>

    <typeAliases>
        <package name="com.edu.pojo"/>
    </typeAliases>

    
<!--    这个不可以写，写了会报错-->
<!--    <mappers>-->
<!--        <mapper class="com.edu.mapper.UserMapper" />-->
<!--    </mappers>-->

</configuration>

  2. 测试

    import com.edu.mapper.UserMapper;
import com.edu.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;
import java.util.List;

/**
 * @author 我
 * @version 1.0
 */
public class MyTest {
    @Test
    public void selectUser() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        for (User user : userMapper.selectUser()) {
            System.out.println(user);
        }
    }
}

整合实现方式二

  1. 新建一个UserMapperImpl2

    package com.edu.mapper;

import com.edu.pojo.User;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import java.util.List;

/**
 * @author 我
 * @version 1.0
 */
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{

    @Override
    public List<User> selectUser() {
        return getSqlSession().getMapper(UserMapper.class).selectUser();
    }
}

    创建一个applicationConfig.xml，整合配置文件

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

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


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



    <bean id="userMapper2" class="com.edu.mapper.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

</beans>

    把spring-dao.xml修改为

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

    <!--    第一步：配置数据源替换mybatis的数据源-->

    <!--DataSource: 使用spring的数据源替换mybatis的配置
        此处使用spring提供的jdbc：org.springframework.jdbc.datasource-->
    <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

    <!--    第二步：配置SqlSessionFactory，关联Mybatis-->

    <!--sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="datasource"/>
        <!--绑定Mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/edu/mapper/*.xml"/>
    </bean>

    <!--    第三步：注册sqlSessionTemplate，关联sqlSessionFactory-->

    <!--SqlSessionTemplate: 就是我们使用的sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入sqlSessionFactory,因为其没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

</beans>

Spring中的事务管理

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

编程式事务管理

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

声明式事务管理

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

例子：

  1. 利用上面案例的代码新建一个项目，为userMapper接口新增两个方法，删除和增加用户；

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

    //添加一个用户
    public int addUser(User user);

    //删除一个用户
    public int deleteUser(int id);
}

  2. UserMapper.xml文件中，故意将deletes写错，测试是否能够删除。下面的是写对的，自己改错即可

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

<!--namespace=绑定一个指定的Dao/Mapper接口-->
<mapper namespace="com.edu.mapper.UserMapper">
    <select id="selectUser" resultType="user">
        select * from user
    </select>

    <insert id="addUser" parameterType="user">
        insert into user(id,name,pwd) values(#{id},#{name},#{pwd})
    </insert>


    <delete id="deleteUser" parameterType="int">
        delete from user where id = #{id}
    </delete>
</mapper>

  3. 编写接口的UserMapperImpl2实现类

    package com.edu.mapper;

import com.edu.pojo.User;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import java.util.List;

/**
 * @author 我
 * @version 1.0
 */
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{

    @Override
    public List<User> selectUser() {
        User user = new User(8, "xx", "2222");
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        mapper.addUser(user);
        mapper.deleteUser(4);
        return mapper.selectUser();
    }

    @Override
    public int addUser(User user) {
        return getSqlSession().getMapper(UserMapper.class).addUser(user);
    }

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

    }
}

  4. 测试类

    结果:发现报错，但是还是能插入成功

    public class MyTest {
   
      @Test
    public void selectUser2() throws IOException{
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationConfig.xml");
        UserMapper userMapper2 = context.getBean("userMapper2", UserMapper.class);
        for (User user : userMapper2.selectUser()) {
            System.out.println(user);
        }
    }
}

  5. 使用Spring事务管理，需要在spring-dao.xml中导入头文件的约束：tx

    xmlns:tx="http://www.springframework.org/schema/tx"

http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd"

  6. 配置声明事务 spring-dao.xml

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

  7. 配置事务的通知 spring-dao.xml

        <!--结合AOP实现事务的植入-->
    <!--配置事务通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--给哪些方法配置事务-->
        <!--配置事务的传播特性： new propagation-->
        <tx:attributes>
            <tx:method name="add" propagation="REQUIRED"/>
            <tx:method name="delete" propagation="REQUIRED"/>
            <tx:method name="update" propagation="REQUIRED"/>
            <tx:method name="query" propagation="REQUIRED"/>
            <!--正常写下面一行即可：配置全部的方法-->
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

  8. 配置事务切入 spring-dao.xml

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

  9. 总的配置文件如下：

    spring-dao.xml

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

    <!--    第一步：配置数据源替换mybatis的数据源-->

    <!--DataSource: 使用spring的数据源替换mybatis的配置
        此处使用spring提供的jdbc：org.springframework.jdbc.datasource-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

    <!--    第二步：配置SqlSessionFactory，关联Mybatis-->

    <!--sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--绑定Mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/edu/mapper/*.xml"/>
    </bean>

    <!--    第三步：注册sqlSessionTemplate，关联sqlSessionFactory-->

    <!--SqlSessionTemplate: 就是我们使用的sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入sqlSessionFactory,因为其没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>


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

    <!--结合AOP实现事务的植入-->
    <!--配置事务通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--给哪些方法配置事务-->
        <!--配置事务的传播特性： new propagation-->
        <tx:attributes>
            <tx:method name="add" propagation="REQUIRED"/>
            <tx:method name="delete" propagation="REQUIRED"/>
            <tx:method name="update" propagation="REQUIRED"/>
            <tx:method name="query" propagation="REQUIRED"/>
            <!--正常写下面一行即可：配置全部的方法-->
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

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

</beans>

    applicationConfig.xml

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

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

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


    <bean id="userMapper2" class="com.edu.mapper.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

</beans>

  10. 测试，这时候即使会报错，但是报错时马，就会不在添加进去了

public class MyTest {
 
      @Test
    public void selectUser2() throws IOException{
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationConfig.xml");
        UserMapper userMapper2 = context.getBean("userMapper2", UserMapper.class);
        for (User user : userMapper2.selectUser()) {
            System.out.println(user);
        }
    }
}

思考：

为什么需要事务？

  • 如果不配置事务，可能存在数据提交不一致的情况；

  • 如果我们不在Spring中去配置声明式事务，我们就需要在代码中手动配置事务！

  • 事务在项目的开发中十分重要，涉及到数据的一致性和完整性问题，不容马虎！


    <tx:advice id=“txAdvice” transaction-manager=“transactionManager”>


    tx:attributes
    <tx:method name=“add” propagation=“REQUIRED”/>
    <tx:method name=“delete” propagation=“REQUIRED”/>
    <tx:method name=“update” propagation=“REQUIRED”/>
    <tx:method name=“query” propagation=“REQUIRED”/>

    <tx:method name=“*” propagation=“REQUIRED”/>
    </tx:attributes>
    </tx:advice>

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

    applicationConfig.xml

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

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

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


    <bean id="userMapper2" class="com.edu.mapper.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

</beans>
  1. 测试，这时候即使会报错，但是报错时马，就会不在添加进去了
public class MyTest {
 
      @Test
    public void selectUser2() throws IOException{
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationConfig.xml");
        UserMapper userMapper2 = context.getBean("userMapper2", UserMapper.class);
        for (User user : userMapper2.selectUser()) {
            System.out.println(user);
        }
    }
}

思考：

为什么需要事务？

  • 如果不配置事务，可能存在数据提交不一致的情况；
  • 如果我们不在Spring中去配置声明式事务，我们就需要在代码中手动配置事务！
  • 事务在项目的开发中十分重要，涉及到数据的一致性和完整性问题，不容马虎！
小墩墩~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Spring学习笔记
weixin_43877653的博客
07-22 561
Spring学习笔记依赖注入（dependency injection，DI）概况三面向切面编程(aspect-oriented programming,AOP) 依赖注入（dependency injection，DI） 概况 三 面向切面编程(aspect-oriented programming,AOP)
Spring学习笔记.zip
03-18
根据提供的压缩包文件名，我们可以推测这是一个逐步学习Spring的系列笔记。从"Spring_day1"开始，可能涵盖了Spring的基础概念、环境搭建和基本配置。"Spring_day2"可能涉及了依赖注入和AOP的深入讲解。"Spring_day3...
Spring学习笔记（一）
YinXin的博客
10-27 122
什么是控制反转？ 控制：一般程序会主动创建对象，并控制对象。 反转：正转是我们需要对创建的对象主动去设置依赖的资源和对象。反转，我们不用主动去设置。 IOC容器帮我们去控制我们所需要的对象，并且对象所以来的资源，IOC去创建并帮我们设置好，所有，当我们从IOC容器拿到对象后，这个对象可以直接使用，提高了程序的功能复用，并进行了解耦。 什么是依赖注入？ 依赖了什么：应用程序需要依赖IOC容器来获得资...
Spring学习笔记(1)
特立独行
12-09 389
l       Spring提供的IoC(控制翻转)容器依赖注入:IoC容器有三种依赖注入方式，（1）构造方法注入：在构造方法中注入所需要的以来组件；（2）设置属性注入：Spring的IoC容器推荐的方式，通过简单的setter方法注入；（3）接口注入：在接口中定义需要注入的信息。       IoC容器使用工厂模式创建需要的JavaBean,如图一： 图一XML配置文件示
Spring Cloud Alibaba学习笔记
最新发布
03-18
Spring Cloud Alibaba学习笔记 内容简介： 1、微服务介绍 2、微服务环境搭建 3、Nacos Discovery--服务治理 4、Gateway--服务网关 5、Sleuth--链路追踪 6、Rocketmq--消息驱动 7、SMS--短信服务 8、Sentinel--服务...
javaSpring学习笔记
03-12
“Java Spring学习笔记”是一份宝贵的资源，专门为想要学习和掌握Java Spring框架的开发者而设计。这份学习笔记提供了详细而系统的教程和实践指南，帮助初学者快速入门，并带领已经有一定经验的开发者深入理解和应用...
Spring学习笔记 自我总结
11-02
spring学习笔记
spring学习笔记1
03-16
spring学习笔记1
Spring学习笔记（全）
Ur_Eyes_的博客
08-10 456
Spring的概述 Spring是什么？ Spring是分层的JavaSE/JavaEE应用full-stack的轻量级开源框架，以IOC（Inverse Of Control，控制反转）和AOP（Aspect Oriented Programming，面向切面编程）为核心，提供了表现层SpringMVC和持久层Spring JDBC以及业务层事务管理等众多企业级应用技术的支持，还可以整合众多第三方框架。 Spring的优势 方便解耦，简化开发 AOP 编程的支持 声明式事务的支持 方便程序的测试 方
spring 学习笔记
流沙-岁月
07-13 341
一. AOP       OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小墩墩~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值