Spring【IOC & AOP】

最新推荐文章于 2024-07-09 17:58:26 发布
最新推荐文章于 2024-07-09 17:58:26 发布
阅读量105 收藏
点赞数
分类专栏： Java后端 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44799103/article/details/129316866
版权

1. Spring

1.1 简介

  • Spring：软件行业的春天。

  • 2002年，首次推出了Spring框架的雏形，interface 21框架；

  • Spring框架即以interface21 框架为基础，经过重新设计，并不断丰富其内涵，2004.3.24 发布1.0 版本；

  • Rod Johnson 创始人，是音乐学博士。。。【音符转码？】

  • Spring理念：使现有的技术更加容易使用，本身是一个大杂烩。，整合了现有的技术框架。

  • SSH: Struct2+Spring+Hibernate

  • SSM: SpringMvc + Spring + MyBatis

官网：https://docs.spring.io/spring-framework/docs/current/reference/html/
官方下载地址：http://repo.spring.io/release/org/springframework/spring
GitHub:https://github.com/spring-projects/spring-framework

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

1.2 优点

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

Spring就是一个轻量级的控制反转和面向切面编程的框架。

1.3 组成

在这里插入图片描述

1.4

现代化的Java开发，就是基于Spring的开发。

  • Spring boot
    • 一个快速开发的脚手架。
    • 基于SpringBoot可以快速的开发单个微服务。
    • 约定大于配置。
  • Spring Cloud
    • SpringCloud是基于SpringBoot实现的。

因为现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring及SpringMVC。承下启下的作用。

弊端：发展了太久之后，违背了原来的理念，配置十分繁琐，人称配置地狱。

2. IOC理论推导

  1. UserDao 接口
  2. UserDaoImpl 实现类
  3. UserService 业务接口
  4. UserServiceImpl 业务实现类
    在这里插入图片描述
    在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改源代码。如果程序代码量十分大，修改一次的成本代价十分昂贵。

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

private UserDao userDao;

    // 利用set进行动态实现值的注入
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
  • 之前，程序是主动创建对象，控制权在程序员手上!
  • 使用了set注入后，程序不再具有主动权，而是变成了被动的接受对象！

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

IOC本质

控制反转（IOC）是一种设计思想，DI（依赖注入）是实现IOC的一种方法。没有IOC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，所谓的控制反转就是：获得依赖对象的方式反转了。

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

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

3. HelloSpring

Bean.xml

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

    <bean id="mysqlImpl" class="com.mao.dao.UserDaoMysqlImpl"/>
    <bean id="oracleImpl" class="com.mao.dao.UserDaoOracleImpl"/>

    <bean id="UserServiceImpl" class="com.mao.service.UserServiceImpl">
        <!--
            ref: 引用Spring容器中创建好的对象
            value：具体的值，基本数据类型。
        -->
        <property name="userDao" ref="oracleImpl"/>
    </bean>
</beans>

测试代码

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

        // 获取ApplicationContext；
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("UserServiceImpl");

        userServiceImpl.getUser();

    }
}

修改配置文件达到更改需求的目的。

4. IOC创建对象的方式

  1. 默认使用无参构造创建对象；
  2. 假如我们要使用有参构造创建对象；
<!--第一种，下标赋值-->
<bean id="user" class="com.mao.pojo.User">
    <constructor-arg index="0" value="laomaoNo1"/>
</bean>
<!--第二种，通过类型创建，不建议使用-->
<bean id="user" class="com.mao.pojo.User">
    <constructor-arg type="java.lang.String" value="xiaole"/>
</bean>
<!--第三种，通过参数名-->
<bean id="user" class="com.mao.pojo.User">
    <constructor-arg name="name" value="猫"/>
</bean>

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了。

5. Spring配置

5.1 别名 alias

如果添加了别名，我们也可以通过别名获取到这个对象

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

5.2 Bean配置

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

<bean id="user" class="com.mao.popjo.UserT" name="u2,u3 u4;u5"/>

5.3 import

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

  • 张三
  • 李四
  • 王五
  • applicationContext.xml
<import resource="beans.xml">
<import resource="beans2.xml">
<import resource="beans3.xml">

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

6. DI依赖注入

6.1 构造器注入

6.2 set方式注入【重点】

  • 依赖注入：Set注入
    • 依赖：bean对象的创建依赖于容器
    • 注入：bean对象中的所有属性，由容器来注入
      【环境搭建】
  1. 复杂类型
package com.mao.pojo;

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}
  1. 真实测试对象
public class Student {

    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbies;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private Properties info;
    
}
  1. beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="address" class="com.mao.pojo.Address"/>

    <bean id="student" class="com.mao.pojo.Student">
        <!--普通值注入，value-->
        <property name="name" value="老猫"/>
        <!--bean注入，ref-->
        <property name="address" ref="address"/>
        <!--数组-->
        <property name="books">
            <array>
                <value>红楼梦</value>
                <value>西游记</value>
                <value>水浒传</value>
                <value>三国演义</value>
            </array>
        </property>
        <!--List-->
        <property name="hobbies">
            <list>
                <value>听歌</value>
                <value>敲代码</value>
                <value>看论文</value>
                <value>做实验</value>
            </list>
        </property>
        <!--map-->
        <property name="card">
            <map>
                <entry key="身份证" value="111111111111111111"/>
                <entry key="银行卡" value="111111"/>
            </map>
        </property>
        <!--set-->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>COC</value>
                <value>BOB</value>
            </set>
        </property>
        <!--null-->
        <property name="wife">
            <null/>
        </property>
        <!--Property-->
        <property name="info">
            <props>
                <prop key="学号">201702801200</prop>
                <prop key="性别">男</prop>
                <prop key="姓名">小乐</prop>
            </props>
        </property>
    </bean>
</beans>
  1. 测试类
public class MyTest {

    public static void main(String[] args) {

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.toString());

    }
}
/*
Student{name='老猫', address=Address{address='null'}, books=[红楼梦, 西游记, 水浒传, 三国演义], hobbies=[听歌, 敲代码, 看论文, 做实验], card={身份证=111111111111111111, 银行卡=111111}, games=[LOL, COC, BOB], wife='null', info={学号=201702801200, 性别=男, 姓名=小乐}}

Process finished with exit code 0
*/

6.3 拓展方式注入

p

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

	<!--p命名空间注入，可以直接注入属性的值：property-->
    <bean id="user" class="com.mao.pojo.User" p:name="拉毛" p:age="18"/>

测试

@Test
public void test2(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
    User user = context.getBean("user", User.class);
    System.out.println(user);
}

c

	xmlns:c="http://www.springframework.org/schema/c"
	
	<!--c命名空间注入，通过构造器注入：construct-->
    <bean id="user2" class="com.mao.pojo.User" c:age="18" c:name="漂泊"/>

测试

@Test
public void test2(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
    User user = context.getBean("user2", User.class);
    System.out.println(user);
}

注意点：p和c命名空间不能直接使用，需要导入xml约束。

6.4 Bean的作用域 【Scope】

在这里插入图片描述

  1. singleton 单例模式（Spring默认机制）
<bean id="user" class="com.mao.pojo.User" p:name="拉毛" p:age="18" scope="singleton"/>
  1. prototype 原型模式（每次从容器中get的时候，都会产生一个新对象）
<bean id="user" class="com.mao.pojo.User" p:name="拉毛" p:age="18" scope="prototype"/>
  1. 其余的request、session、application，这些只能在web开发中使用到。

7. Bean的自动装配

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

在Spring中有三种装配方式：

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

7.1 测试

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

7.2 ByName自动装配

<!--会自动在容器上下文查找，和自己对象set方法后面的值对应的beanid-->
<bean id="people" class="com.mao.pojo.People" autowire="byName">
    <property name="name" value="小乐"/>
	<!--<property name="cat" ref="cat"/>-->
	<!--<property name="dog" ref="dog"/>-->
</bean>

7.3 ByType自动装配

<!--byname:会自动在容器上下文查找，和自己对象set方法后面的值对应的beanid-->
<!--bytype:会自动在容器上下文查找，和自己对象属性类型相同的beanid【要求类型全局唯一】-->
<bean id="people" class="com.mao.pojo.People" autowire="byType">
    <property name="name" value="小乐"/>
	<!--<property name="cat" ref="cat"/>-->	
	<!--<property name="dog" ref="dog"/>-->
</bean>

小姐：

  • byname的时候，需要保证所有的bean的id唯一，并且这个bean需要和自动注入的属性的方法的值一致；
  • bytype的时候，需要保证所有的bean的class唯一，并且这个bean需要和自动注入的属性的类型一致。

7.4 使用注解实现自动装配

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

要使用注解须知：

  • 导入约束 context
  • 配置注解的支持 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"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

</beans>

@Autowired
直接在属性上使用即可。也可以在set方式上使用，使用Autowired我们可以不用编写Set方法，前提是这个自动装配的属性在IOC（Spring）容器中存在，且符合名字byname。
科普：

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

// 如果显示定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空。
@Autowired(required = false)

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

public class People{
	@Resource(name = "cat2")
	private Cat cat;

	@Resource
	private Dog dog;
}

小结：
@Resource 和 @Autowired区别

  • 都是用来自动装配的，都可以放在属性字段上；
  • @Autowired通过byType的方式实现，必须要求这个对象存在；
  • @Resource默认通过byname的方式实现，如果找不到名字，则通过bytype实现，两个都找不到，报错。
  • 执行顺序不同：@Autowired通过bytype实现，@Resource默认通过byname的方式实现。

8. 使用注解开发

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

使用注解时需要导入context约束，增加注解的支持。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd">
    
    <!--指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.mao"/>
    <context:annotation-config/>
    
</beans>
  1. bean
  2. 属性如何注入
  3. 衍生的注解
    @Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层。
    • dao【@Repository】
    • service 【@Service】
    • controller 【@Controller】
      这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean
  4. 自动装配
  5. 作用域
    @Scope(“singleton”)
  6. 小结
    xml 与注解：
    • xml更加万能，适用于任何场合！维护简单方便！
    • 注解 不是自己类用不了，维护相对复杂。
      最佳实践：
    • xml用来管理Bean；
    • 注解只负责完成属性的注入。
    • 在使用过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持。
<!--指定要扫描的包，这个包下的注解就会生效-->
<context:component-scan base-package="com.mao"/>
<context:annotation-config/>

9. 使用Java的方式配置Spring

我们现在要完全不使用Spring的xml配置了，全权交给Java来做。
JavaConfig是Spring的一个子项目，在Spring4之后，它成为了一个核心功能。

配置文件

// 这个也会Spring容器托管，注册到容器中，因为它本来就是一个@Componen
// @Configuration代表这是一个配置类，就和我们之前看的bean.xml
@Configuration
@Import(MaoConfig2.class)
public class MaoConfig {

    // 注册一个Bean，就相当于我们之前写的一个Bean标签
    // 这个方法的名字，就相当于bean标签的id属性
    // 这个方法的返回值，就相当于bean标签中的class属性
    @Bean
    public User getUser(){
        return new User();
    }
}

实体类

package com.mao.pojo;

public class User {
    private String name;

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

    public String getName() {
        return name;
    }

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

测试类

@Test
public void getUser(){
    // 如果完全使用了配置类方式去做，我们就只能通过 AnnotationConfig 上下文来获取容器，通过配置类的class对象加载。
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MaoConfig.class);
    User getUser = (User)context.getBean("getUser");
    System.out.println(getUser.getName());
}

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

10. 代理模式

为什么学习代理模式？
因为这就是SpringAOP的底层！【SpringAOP 和SpringMVC】
代理模式的分类：

  • 静态代理
  • 动态代理

10.1 静态代理

角色分析：

  • 接口
package com.mao.demo01;

public interface Rent {
    public void rent();
}
  • 抽象角色：一般会使用接口或者抽象类来解决
package com.mao.demo01;

public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        Proxy proxy = new Proxy(host);
        proxy.rent();
    }
}
  • 真实角色：被代理的角色
package com.mao.demo01;

public class Host implements Rent {
    @Override
    public void rent() {
        System.out.println("房东要出租房子");
    }
}
  • 代理角色：代理真实角色，一般会做一些附属操作。
package com.mao.demo01;

public class Proxy implements Rent{
    private Host host;

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

    @Override
    public void rent() {
        host.rent();
    }
}

代理模式的好处：

  • 可以使真实角色的操作更加纯粹，不用去关注一些公共的业务。
  • 公共业务就交给代理角色，实现了业务的分工。
  • 公共业务发生拓展的时候，方便集中管理。
    缺点：
    一个真实角色就会产生一个代理角色，代码量会翻倍~开发效率会变低。

10.2 加深理解

在这里插入图片描述

10.3 动态代理

  • 动态代理和静态代理角色一样
  • 动态代理类是动态生成的，不是我们直接写好的。
  • 动态代理分为两大类：基于接口的动态代理，基于类的动态代理。
    • 基于接口—jdk动态代理【我们在这里使用】
    • 基于类：cglib
    • java字节码实现：Javassist

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

动态代理的好处：

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

11. AOP

11.1 什么是AOP

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

11.2 AOP在Spring中的作用

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

  • 横切关注点：跨越应用程序多个模块的方法和功能。即是：与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如：日志，安全，缓存，事务等。。
  • 切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。
  • 通知（Advice）：切面必须要完成的工作。即：它是类中的一个方法。
  • 目标（Target）：被通知的对象
  • 代理（Proxy）：向目标对象应用通知之后创建的对象。
  • 切入点（PointCut）：切面通知 执行的 地点 的定义。
  • 连接点（JointPoint）：与切入点匹配的执行点。
    在这里插入图片描述

11.3 使用Spring实现AOP

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

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

方式一：使用Spring的API接口

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

    <bean id="userService" class="com.mao.service.UserServiceImpl"/>
    <bean id="log" class="com.mao.log.Log"/>
    <bean id="afterLog" class="com.mao.log.AfterLog"/>


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

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

</beans>

测试

import com.mao.service.UserService;
import com.mao.service.UserServiceImpl;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

方式二：自定义类来实现AOP

<!--方式二： 自定义类-->
<bean id="diy" class="com.mao.diy.DiyPointCut"/>

<aop:config>
    <aop:aspect ref="diy">
        <aop:pointcut id="point" expression="execution(* com.mao.service.UserServiceImpl.*(..))"/>
        <aop:before method="before" pointcut-ref="point"/>
        <aop:after method="after" pointcut-ref="point"/>
    </aop:aspect>
</aop:config>

方式三：使用注解实现

    <!--方式三：通过注解实现-->
    <bean id="annotationPointCut" class="com.mao.diy.AnnotationPointCut"/>
    <!--开启注解支持！ JDK（默认 proxy-target-class="false"）cglib(proxy-target-class="true")-->
    <aop:aspectj-autoproxy/>

package com.mao.diy;

// 使用注解实现AOP

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect // 标注这个类是一个切面
public class AnnotationPointCut {
    @Before("execution(* com.mao.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("前");
    }

    @After("execution(* com.mao.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("后");
    }

    @Around("execution(* com.mao.service.UserServiceImpl.*(..))")
    public void round(){
        System.out.println("环绕前");
    }
}

12. 整合MyBatis

步骤：

  1. 导入相关Jar包
    • junit
    • mybatis
    • mysql数据库
    • spring相关
    • aop植入
    • mybatis-spring【new， 专门整合spring和mybatis】
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </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-webmvc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</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.26</version>
        </dependency>
    </dependencies>
  1. 编写配置文件
  2. 测试

12.1 回忆mybatis

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

12.2 MyBatis-Spring

  1. 编写数据源配置
  2. sqlSessionFactory
  3. sqlSessionTemplate
  4. 需要给接口加实现类
  5. 将自己写的实现类，注入到Spring中
  6. 测试
    spring.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--DataSource:使用Spring的数据源替换MyBatis的配置 c3p0 dbcp druid
    使用Spring提供的JDBC
    -->
    <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=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

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

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

</beans>

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.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.mao.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

</beans>

13. 声明式事务

1. 回顾事务

  • 要么都成功，要么都失败
  • 事务在项目开发中，十分的重要，涉及数据的一致性问题！
  • 确保完整性和一致性。

事务ACID原则：

  • 原子性
  • 一致性
  • 隔离性
    • 多个业务可能操作同一个资源，防止数据损坏
  • 持久性
    • 事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久写入存储器中。

2. Spring中的事务管理

  • 声明式事务：AOP
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--DataSource:使用Spring的数据源替换MyBatis的配置 c3p0 dbcp druid
    使用Spring提供的JDBC
    -->
    <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=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

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

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

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

    <!--结合AOP实现事务的植入-->
    <!--配置事务通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--给哪些方法配置事务-->
        <!--配置事务的传播特性：new propagation-->
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!--配置事务切入-->
    <aop:config>
        <aop:pointcut id="txPointCut" expression="execution(* com.mao.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>
</beans>
  • 编程式事务：需要在代码中，进行事务的管理。
漂泊老猫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【体系-单体架构】09-Web架构升级之Spring
SomeWay
06-08 226
使用spring升级web应用
Spring的IOC与AOP
weixin_44738308的博客
07-08 176
一、Spring IOC  IOC（控制反转）将创建对象的权利交由Spring创建，是一种降低程序之间耦合度的有效方案。   解耦体现：如果指定对象的jar包没有导入，项目编译即报错可能所有涉及相关jar包的都会有红色波浪线的出现，而使用Spring IOC获取对象项目运行时报错。要知道系统编译通过说明语法上是没有问题的。 1. 工厂模式   Spring IOC 使用工厂设计模式解耦，通过反射技术创建对象。 （1）核心容器的创建：   1）Applicationcontext：单例对象适用，读取配置文件之
Spring官网下载各版本的jar包
whb5566的博客
05-21 2798
原文：https://blog.csdn.net/frankarmstrong/article/details/698088131、在浏览器输入spring官网地址：http://spring.io/projects2、点击如图树叶页面按钮。 3、点击如图小猫图片按钮。 4、查找Spring Framework Artifacts链接点击。 5、查找Spring Repositories下面的 h...
spring下载，Apache-log下载，以及spring项目的安装和测试
qq_46199553的博客
07-22 969
1.首选要对spring进行相关的下载，在地址栏输入spring.io,进入，点击spring framework ， 2.点击猫 3.点击Spring Framework Artifacts 4.点击 https://repo.spring.io. 5.点击release-org-springframework-spring 6.url to file就是下载的路径，然后进行相关的版本的下载 7.对于spring还需要下载一个log文件 网站如下：http://commons.apache.
一周发布30多个版本，Spring 6.0开始爆发
码农小胖哥
11-22 706
从Spring Framework 6.0正式发布开始，Spring团队开启了“爆兵模式”，近一周发布了30多个版本近期Spring发布计划基本上每个组件都多版本同时发布，18日Spring Data系列竟然发布了三个新版本；而昨天应该是版本发布最密集的一天，Spring Amqp、Spring Kafka、Spring Restdocs、Spring Security等都是多版本齐发。就在刚刚 ...
Spring6.0全新发布，快来看看
Jan's的博客
10-25 6454
的第二个里程碑和对应的Spring Boot 3.0第一个里程碑将和大家见面。的代理机制将失效， 请为此类控制器启用基于类的代理。的持久层规范也将在此次里程碑版本中完成迁移。此外，团队称预估整体的项目在11月正式 GA。），以及对其他基础设施的修改。也并非新的技术，前身是Java的J2EE。在本次里程碑版本中涉及到的两个核心容器规范。作为重大更新，他直接舍弃一以往版本的。不是什么新技术，那么由来在这说一下。的组件已经在本次里程碑版本中移除。之前默认情况以下代码是可以的。是目前里程碑版本的基准线。
Spring注解实现IOC和AOP
weixin_73468155的博客
08-29 335
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考AspectJ 面向切面的框架，它扩展了Java语言，定义了AOP 语法，能够在编译期提供代码的织入。...
Spring IOC和aop的原理及实例详解
08-25
Spring IOC和AOP的原理及实例详解 在软件开发中，控制反转（IOC）和面向切面编程（AOP）是两种非常重要的设计模式。Spring框架正是基于这两种模式的思想设计的。下面我们将详细介绍Spring IOC和AOP的原理及实例详解...
SpringIOC和AOP原理设计模式
01-27
Spring框架的核心特性主要体现在Spring的IOC（Inversion of Control，控制反转）和AOP（Aspect-Oriented Programming，面向切面编程）上。这两个概念在实际的软件开发中扮演着非常重要的角色，能够极大地提高代码的...
springIOC与AOP配置
07-03
Spring框架是Java开发中不可或缺的一部分，它通过引入依赖注入（IOC）和面向切面编程（AOP）的概念，极大地简化了应用程序的构建和管理。在本文中，我们将深入探讨Spring的IOC容器和AOP的核心概念，以及如何进行相关...
springioc和spring aop
09-05
Spring框架是Java开发中不可或缺的一部分，它通过提供两种核心特性——控制反转（IoC）和面向切面编程（AOP）来简化应用的构建。理解并掌握这两种技术对于任何Java开发者来说都至关重要。 **控制反转（IoC）**，也...
Spring核心IoC和AOP的理解
08-31
Spring核心IoC和AOP的理解 本文主要介绍了Spring核心IoC和AOP的相关知识，涵盖了IoC和AOP的概念、特点、优点和应用场景等方面的内容。 一、IoC（Inversion of Control） IoC是一种设计模式，目的是为了降低应用...
“Spring Boot精粹：深入理解依赖注入、AOP、IOC和Bean生命周期“
来自上海的这位朋友
04-28 388
本文详细探讨了Spring Boot中的依赖注入、AOP、IOC和Bean生命周期的关键概念。文章通过实际案例和讲解，阐述了依赖注入的实现方法，如@Autowired、@Resource注解以及Java配置类；AOP的应用，如日志记录、事务管理和权限控制等功能；IOC的核心思想，即通过将对象的创建、配置和管理交给容器来实现；以及Bean生命周期的各个阶段，包括实例化、属性设置、初始化、使用和销毁。此外，文章还介绍了如何解决依赖注入歧义性、进行环境配置和启用特定功能等扩展主题。掌握这些概念并在实际项目中应用，
Spring6 正式发布！重磅更新，是否可以拯救 Java
宋小生-中间件
12-05 3303
Spring Framework6 和 Spring Boot3 是一个跨越式的升级整个框架支持的最低 JDK 版本直接跨越到 JDK17，无论框架层还是基础设施层都做了巨大的改变，Spring 6.0 新框架具体做了哪些功能的升级与改进，是否有必要升级与使用呢？可以继续看一看。下面可以先看下翻译自 Spring 官方社区一个宣导博客尊敬的 Spring 社区：我很高兴地宣布，现在 MavenCentral 已经可以提供 SpringFramework6.0.0 了！这是 2023 年及以后新一代框架的开始
IOC+DI(依赖注入)+AOP
Pig-pig-pig的博客
10-03 381
Spring框架 Spring 开源 轻量级框架 2003 兴起 目的：解决企业应用的复杂性创建的 核心：控制反转(IOC) 和 面向切面(AOP) Spring优点: 开源免费框架（容器） 轻量级，非侵入式框架 控制反转(IOC) 和 面向切面(AOP) 良好的事务支持（声明式事务） 高内聚，低耦合 一.IOC容器(控制反转) Srping 核心，容器将创建对象，把他们连接到一起，配置他们，并管理他们的生命周期（创建到销毁） Spring容器使用依赖注入（DI）来管理组成一个应用程序的组件，这些对象
第二章：Spring核心思想和IOC和AOP依赖注入
beiback的博客
11-18 698
Spring核心思想IOC和AOP
Spring：IOC、依赖注入、AOP是什么？
桔子
09-06 1080
Java：反射 Java：设计模式 Java：反射动态代理 博主前言：上面三个知识点是理解Sprig中IOC、依赖注入、AOP的基础，如果不清楚的，还请先看完上面三篇博客。 大白话解释Spring中的IOC、依赖注入、AOP是什么 IOC（控制权反转） 工厂模式就是体现IOC的一种方法。工厂模式中Factory类就像是一个容器，其他类创建对象皆从该容器中取，而不再是自己主动new出来的，...
SpringBootV12和mybatis全部知识点
最新发布
近日终于有时间好好回顾下一些作品了，有帮助的好好看就行
07-09 1048
框架: 快速开发项目的一个架子sshssmspring --> applicationContext.xml配置文件(spring不是业务层,是管理其他框架的)springmvc --> springmvc.xml配置文件 (对应之前servlet)mybatis —> mybatis-config.xml配置文件(对应之前jdbc)—> springboot优化了之前的框架配置,思想是约定大于配置注意：根据网络状况，可能会提示无法连接。如果不能连接，使用http://start.springboot.io
完整版Java web开发教程PPT课件 Java开发进阶教程 第13章 spring ioc aop（共18页）.pptx
12-25
本资源是一份完整的Java web开发教程，涵盖了Java进阶课程的多个关键章节，其中第13章专门讲解Spring的IoC（Inversion of Control）和AOP（Aspect Oriented Programming）技术。Spring是一个2003年由Rod Johnson发起...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值