Spring笔记

已于 2022-02-22 19:03:14 修改
阅读量1k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Spring 文章标签： spring java
于 2022-02-03 00:47:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46799925/article/details/122771199
本文深入探讨了Spring框架的核心特性，包括IOC（控制反转）的概念、依赖注入的不同方式，如构造器注入和Set注入，以及别名和bean的作用域。此外，还详细讲解了AOP（面向切面编程）的应用，包括通知类型和动态代理，并展示了如何在Spring中实现声明式事务管理。最后，提到了Spring与Mybatis的整合以及声明式事务在确保数据一致性和完整性中的重要性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

1. Spring

1.1 优点

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

总结：Spring就是一个轻量级的控制反转（IOC），面向切面编程（AOP）的框架

1.2 组成

在这里插入图片描述

1.3 拓展

在Spring的官网有这个介绍：现代化的Java开发！ 说白就是基于Spring的开发！
在这里插入图片描述

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

现在大多数公司都在使用Spring Boot进行快速开发，学习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的原型！

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

3.HelloSpring

在这里插入图片描述
Hello实体类

package com.du.pojo;

public class Hello {
    private String str;

    public String getStr() {
        return str;
    }

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

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

beans.xml配置文件

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

<!--    使用Spring来创建对象，在Spring这些都成为Bean
        类型  变量  = new  类型（）；
        Hello hello = new Hello（）；
         bean = 对象  new Hello（）；

        id = 变量名
        class = new 的对象
        property 相当于给对象种设置值
-->
    <bean id="hello" class="com.du.pojo.Hello">
        <property name="str" value="String"></property>
    </bean>
</beans>

测试类

import com.du.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        //获取Spring的上下文对象！
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //我们的对象现在都在Spring种的管理了，我们要使用，直接去里面取出来就可以了
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

思考问题

  • Hello对象是谁创建的？
    hello对象由Spring创建
  • Hello对象属性是怎么设置的？
    由Spring设置

这个过程叫反转

控制∶谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的．

反转:程序本身不创建对象，而变成被动的接收对象．
依赖注入:就是利用set方法来进行注入的.

IOC是一种编程思想，由主动的编程变成被动的接收．

可以通过newClassPathXmIApplicationContext去浏览一下底层源码．

OK，到了现在，我们彻底不用再程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓的loc,一句话搞定:对象由Spring 来创建，管理，装配!

4. IOC创建对象的方式

1.使用无参构造创建对象
2.假设使用有参构造创建对象
1.下标赋值

	<!--    第一种下标赋值-->
    <bean id="user" class="com.du.pojo.User">
        <constructor-arg index="0" value="杜先生"/>
    </bean>

2.类型创建

<!--    第二种，通过类型创建，不建议使用！-->
    <bean id="user" class="com.du.pojo.User">
        <constructor-arg type="java.lang.String" value="杜老师"/>
    </bean>

3.参数命名

<!--    第三种，直接通过参数命名-->
    <bean id="user" class="com.du.pojo.User">
        <constructor-arg name="name" value="杜先生"/>
    </bean>

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

5. Spring配置

5.1 别名

<!--    别名，如果添加别名，可通过别名获取对象-->
    <alias name="user" alias="aaa"/>

5.2 Bean配置


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

    <bean id="userT" class="com.du.pojo.UserT" name="userT2 u3,u4;u5">
        <property name="name" value="杜老师"/>
    </bean>

5.3 import

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

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

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

6. 依赖注入

6.1 构造器注入

前面已经说过了

6.2 Set方式注入【重点】

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

【环境搭建】

  1. 复杂类型
package com.du.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> hobbys;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private Properties  info;
}

3.beans.xml

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

    <bean id="student" class="com.du.pojo.Student">
<!--        第一种，普通值注入，value-->
        <property name="name" value="杜老师"/>
    </bean>
</beans>

4.测试类

import com.du.pojo.Student;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

完善注入信息

<?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.du.pojo.Address">
        <property name="address" value="河北"/>
    </bean>

    <bean id="student" class="com.du.pojo.Student">
<!--        第一种，普通值注入，value-->
        <property name="name" value="杜老师"/>
<!--            第二种，Bean注入，ref-->
        <property name="address" ref="address"/>
<!--        数组注入，ref-->
        <property name="books">
             <array>
                 <value>红楼梦</value>
                 <value>西游记</value>
                 <value>三国演义</value>
                 <value>水浒传</value>
             </array>
        </property>
<!--        List-->
        <property name="hobbys">
            <list>
                <value>听歌</value>
                <value>看电影</value>
                <value>打游戏</value>
            </list>
        </property>
<!--        Map-->
        <property name="card">
            <map>
                <entry key="身份证" value="111"/>
                <entry key="银行卡" value="22"/>
                <entry key="电话" value="333"/>
            </map>
        </property>

<!--        Set-->
        <property name="games">
            <set>
                <value>lol</value>
                <value>王者</value>
                <value>cf</value>
            </set>
        </property>

<!--        null-->
        <property name="wife">
            <null></null>
        </property>
<!--        Properties-->
        <property name="info">
            <props>
                <prop key="学号">123</prop>
                <prop key="姓名">杜老师</prop>
            </props>
        </property>
    </bean>
</beans>

6.3 拓展方式

使用P命名空间和C命名空间注入
官方解释：
在这里插入图片描述
使用：

<?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命名空间注入，可以直接注入属性-->
   <bean id="user" class="com.du.pojo.User" p:name="杜老师" p:age="18"/>

<!--   C命名空间注入，通过构造器注入：construct-args-->
   <bean id="user2" class="com.du.pojo.User" c:age="18" c:name="杜老师"/>


</beans>

测试：

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

    @Test
    public void test3(){
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("userbeans.xml");
        User user = (User) classPathXmlApplicationContext.getBean("user2");
        System.out.println(user);
    }

注意点：P命名空间和C命名空间不能直接命名需要导入xml约束

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

6.4 bean的作用域

在这里插入图片描述
翻译（仅供参考）：
在这里插入图片描述
1.单例模式（Spring默认机制）：共用一个对象

 <bean id="user2" class="com.du.pojo.User" c:age="18" c:name="杜老师" scope="singleton"/>

测试：

  @Test
   public void test4(){
       ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("userbeans.xml");
       User user = (User) classPathXmlApplicationContext.getBean("user2");
       User user2 = (User) classPathXmlApplicationContext.getBean("user2");
       System.out.println(user.hashCode());
       System.out.println(user2.hashCode());
       System.out.println(user == user2);
   }

结果：
在这里插入图片描述

2.原型模式:每次容器中get的时候，都会产生一个新对象

<bean id="user2" class="com.du.pojo.User" c:age="18" c:name="杜老师" scope="prototype"/>

测试：

   public void test4(){
       ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("userbeans.xml");
       User user = (User) classPathXmlApplicationContext.getBean("user2");
       User user2 = (User) classPathXmlApplicationContext.getBean("user2");
       System.out.println(user.hashCode());
       System.out.println(user2.hashCode());
       System.out.println(user == user2);
   }

结果：
在这里插入图片描述
3.其余的request、session、application 这些只能在web开发中使用到

7. bean的自动装配

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

在Spring中有三种装配方式：

  • 在xml中显示的配置
  • 在java中显示配置
  • 隐式 的自动装配bean【重要】

7.1 测试

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

7.2 byName 自动装配

  <bean id="cat" class="com.du.pojo.Cat"/>
    <bean id="dog" class="com.du.pojo.Dog"/>

<!--    byName : 会自动在容器上下文中查找，和自己对象set方法后面的值对应的bean！-->
    <bean id="people" class="com.du.pojo.People" autowire="byName">
        <property name="name" value="杜老师"/>
    </bean>

7.3 byType 自动装配

    <bean class="com.du.pojo.Cat"/>
    <bean class="com.du.pojo.Dog"/>

<!--    byType : 会自动在容器上下文中查找，和自己对象属性类型相同的bean！-->
    <bean id="people" class="com.du.pojo.People" autowire="byType">
        <property name="name" value="杜老师"/>
    </bean>

小结：

  • byname的时候，需要保证所有bean的id唯一，并且bean需要和自动注入的属性的set方法的值一致！
  • byType 的时候，需要保证所有bean的id唯一，并且bean需要和自动注入的属性的类型一致！

7.4 使用注解实现自动装配

jdk1.5支持的注解，Spring2.5就支持注解
使用注解须知：
1.导入约束 。 context约束
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"
    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


    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;
    private String name;

科普：

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

public @interface Autowired {
    boolean required() default true;
}

测试代码：


//    如果显示定义了Autowired的required属性为false，说明这个对象可以为null  否则不能为空
    @Autowired(required = false)
    private Cat cat;
    @Autowired
    private Dog dog;
    private String name;

    public People(@Nullable String name) {
        this.name = name;
    }

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


    @Autowired
    @Qualifier(value = "cat111")
    private Cat cat;
    @Autowired
    @Qualifier(value = "dog222")
    private Dog dog;
    private String name;

  <context:annotation-config/>

    <bean id="cat11" class="com.du.pojo.Cat"/>
    <bean id="cat111" class="com.du.pojo.Cat"/>
    <bean id="dog222" class="com.du.pojo.Dog"/>
    <bean id="dog22" class="com.du.pojo.Dog"/>

    <bean id="people" class="com.du.pojo.People"/>

** @Resource注解**


    @Resource(name = "cat11")
    private Cat cat;
    @Resource
    private Dog dog;
    private String name;

小结：
@Resource和@Autowired的区别：

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

8. 使用注解开发

Spring4之后，要使用注解开发，必须要保证aop的包导入成功
在这里插入图片描述
在使用注解需要导入context约束，增加注解支持

  1. bean
  2. 属性如何注入
package com.du.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

//等价于<bean id="user" class="com.du.pojo.User"/>
@Component
public class User {

    public String name;
//  <property name="name" value="杜老师"/>
    @Value("杜老师")
    public void setName(String name) {
        this.name = name;
    }
}
  1. 衍生的注解
    @Component 有几个衍生注解，我们在web开发中，会按照mvc三层架构分层
    • dao [@Repository]
    • service[@Service]
    • controller [@Controller]
      这4个注解功能一样，都是代表某个类注册到Spring中，装配Bean
  2. 自动配置
    • @Autowired：自动装配通过类型，名字，如果Autowired不能唯一自动装配属性，则通过@Qualifier（value = “xxx”）
    • @Nullable : 字段标记了这个注解，说明可以为null
    • @Resource ：自动装配通过名字，类型
  3. 作用域
@Component
@Scope("singleton")
public class User {

    public String name;
//  <property name="name" value="杜老师"/>
    @Value("杜老师")
    public void setName(String name) {
        this.name = name;
    }
}
  1. 小结
    xml与注解：
    • xml更加万能，适用于任何场合！维护简单方便
    • 注解 不是自己类使用不了，维护相对复杂
      xml与注解的最佳实践：
    • xml用来管理bean
    • 注解只负责完成属性的注入
    • 在使用的过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持

<!--    指定扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.du"/>
    <!--    开启注解支持-->
    <context:annotation-config/>
  • @Component ： 组件，放在类上，说明这个类被Spring管理了，就是bean！

9. 使用java的方式配置Spring

我们现在要完全不使用Spring的xml配置，全权交给Java来做！
JavaConfig是Spring的一个子项目，在Spring 4 之后，成为一个核心功能
在这里插入图片描述
实体类：

package com.du.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

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

    @Value("杜老师")
    public void setName(String name) {
        this.name = name;
    }
}

配置文件：

package com.du.config;

import com.du.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.stereotype.Component;
/*
这个也会被Spring容器托管，注册到容器中，因为他本来就是一个@Component，
@Configuration代表这个是一个配置类，和bean.xml一样
 */

@Configuration
@ComponentScan("com.du.pojo")
@Import(DuConfig2.class)
public class DuConfig {
    //注册一个bean，相当于之前写的一个bean标签，
//    这个方法的名字相当于bean标签的id属性
//    这个返回值，相当于bean标签中的class属性
    @Bean
    public User getUser(){
        return new User();
    }
}

测试类：

import com.du.config.DuConfig;
import com.du.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        //完全使用配置类方式去做，我们就只能通过AnnotationConfig 上下文来获取容器，通过配置类class对象加载！
        ApplicationContext context = new AnnotationConfigApplicationContext(DuConfig.class);
        User getUser = (User) context.getBean("getUser");
        System.out.println(getUser);
    }
}

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

10. 代理模式

为什么要学习代理模式？
因为这即使SpringAOP的底层 【SpringAOP和SpringMVC】
代理模式的分类：

  • 静态代理
  • 动态代理
    在这里插入图片描述

10.1 静态代理

角色分析：

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

代码步骤：

  1. 接口
package com.du.demo01;

//租房
public interface Rent {
    public void rent();
}
  1. 真实角色
package com.du.demo01;
//房东
public class Host implements Rent{

    public void rent() {
        System.out.println("房东要出租房子！");
    }
}
  1. 代理角色
package com.du.demo01;

public class Proxy implements Rent{
    private Host host;

    public Proxy() {
    }

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

    public void rent() {
        seeHouse();
       host.rent();
       fare();
       hetong();
    }
    //看房
    public void seeHouse(){
        System.out.println("中介带你看房");
    }
    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
    //合同
    public void hetong(){
        System.out.println("欠租品合同");
    }
}
``
5. 客户端访问代理角色
```java
package com.du.demo01;

public class Client {
    public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
        //代理，中介帮房东租房子，但是呢，代理一般会有一些附属操作
        Proxy proxy = new Proxy(host);
        //你不用面对房东，直接找中介租房即可！
        proxy.rent();
    }
}

代理模式的好处：

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

缺点：

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

10.2 加深理解

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

10.3 动态代理

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

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

动态代理得好处：

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

代码实现：

package com.du.demo03;

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


package com.du.demo03;

//房东
public class Host implements Rent {

    public void rent() {
        System.out.println("房东要出租房子！");
    }
}


package com.du.demo03;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//等我们会用这个类，自动生成代理类！
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 {

        seeHouse();
        //动态代理得本质，就是使用反射机制实现！
        Object result = method.invoke(rent, args);
        fare();
        return result;
    }

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

    public void fare(){
        System.out.println("收中介费");
    }
}

package com.du.demo03;

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

        //真实角色描写
        Host host = new Host();

        //代理角色 ： 现在没有
        ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
        //通过调用程序处理角色来处理我们要调用得接口对象
        proxyInvocationHandler.setRent(host);

        Rent proxy = (Rent) proxyInvocationHandler.getProxy();
        proxy.rent();

    }
}

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.6</version>
        </dependency>

方法一： 使用Spring 得接口【主要SpringAPI接口实现】

package com.du.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

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

package com.du.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

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

package com.du.service;

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

package com.du.service;

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

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

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

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


<?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.du.service.UserServiceImpl"/>
    <bean id="log" class="com.du.log.Log"/>
    <bean id="afterLog" class="com.du.log.AfterLog"/>
<!--    方式一：使用原生Spring api接口-->
<!--    配置aop: 需要导入aop的约束-->
    <aop:config>
<!--        切入点:
    expression :表达式
    execution(要执行的位置！ * * * * *)
    -->
        <aop:pointcut id="pointcut" expression="execution(* com.du.service.UserServiceImpl.*(..))"/>

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

    </aop:config>

</beans>

测试：

import com.du.service.UserService;
import com.du.service.UserServiceImpl;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

        UserService userService = (UserService) classPathXmlApplicationContext.getBean("userService");
        userService.add();
    }
}

测试结果：
在这里插入图片描述

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

package com.du.diy;

public class DiyPointCut {
    public void before(){
        System.out.println("====方法执行前===");
    }
    public void after(){
        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"
       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.du.service.UserServiceImpl"/>
    <bean id="log" class="com.du.log.Log"/>
    <bean id="afterLog" class="com.du.log.AfterLog"/>

<!--    方式二： 自定义类-->
    <bean id="diy" class="com.du.diy.DiyPointCut"/>
    <aop:config>
<!--        自定义切面，ref要引用的类-->
        <aop:aspect ref="diy">
<!--            切入点-->
            <aop:pointcut id="point" expression="execution(* com.du.service.UserServiceImpl.*(..))"/>
<!--            通知-->
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>

</beans>

测试结果：
在这里插入图片描述
方法三： 使用注解实现！

<?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.du.service.UserServiceImpl"/>
    <bean id="log" class="com.du.log.Log"/>
    <bean id="afterLog" class="com.du.log.AfterLog"/>

<!--    方式三-->

    <bean id="annotationPointCut" class="com.du.diy.AnnotationPointCut"/>
<!--    开启注解支持  JDK(默认proxy-target-class="false") cglib-->
    <aop:aspectj-autoproxy proxy-target-class="false"/>
</beans>

package com.du.diy;

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

//使用注解方式实现AOP
@Aspect  //标注这个类是一个切面
public class AnnotationPointCut {
    @Before("execution(* com.du.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("方法执行前");
    }

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

    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
    @Around("execution(* com.du.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
//
        Signature signature = jp.getSignature();//获取签名
        System.out.println(signature);
//        执行方法
        Object proceed = jp.proceed();
        System.out.println("环绕后");
        System.out.println(proceed);
    }
}

测试结果：
在这里插入图片描述

12. 整合Mybatis

步骤：

  1. 导入相关jar包
    • junit
    • mybatis
    • mysql
    • spring
    • aop织入
    • mybatis-spring [new ]
  2. 编写配置文件
  3. 测试

12.1 回忆mybatis

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

12.2 Mybatis-spring

package com.du.mapper;

import com.du.pojo.User;

import java.util.List;

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

方式一

package com.du.mapper;

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

import java.util.List;

public class UserMapperImpl implements UserMapper{

    //我们所有操作,都使用sqlSession来执行,在原来  现在都是使用SqlSessionTemplate;
    private SqlSessionTemplate sqlSessionTemplate;

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

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

方式二

package com.du.mapper;

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

import java.util.List;

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {

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

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--configuration核心配置文件-->
<mapper namespace="com.du.mapper.UserMapper">
    <select id="selectUser" resultType="user">
        select * from user;
    </select>
</mapper>

package com.du.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private String password;
}

<?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.du.mapper.UserMapperImpl">
        <property name="sqlSessionTemplate" ref="sqlSession"/>
    </bean>

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


<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration核心配置文件-->
<configuration>
    <typeAliases>
        <package name="com.du.pojo"/>
    </typeAliases>

<!--    设置-->

<!--    <settings>-->
<!--        <setting name="" value=""/>-->
<!--    </settings>-->

</configuration>

<?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"
>

<!--    DataSource 使用spring的数据源替换Mybati的配置   c3p0 dbcp
        使用Spring提高的JDBC
-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>
<!--    sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
<!--        绑定Mybatis文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/du/mapper/*.xml"/>

    </bean>
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--        只能使用构造器注入sqlSessionFactory  因为它没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
    <bean id="userMapper" class="com.du.mapper.UserMapperImpl">
        <property name="sqlSessionTemplate" ref="sqlSession"/>
    </bean>
</beans>

import com.du.mapper.UserMapper;
import com.du.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

public class MyTest {
    @Test
    public void test() throws IOException {

        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserMapper userMapper = classPathXmlApplicationContext.getBean("userMapper2", UserMapper.class);

        for (User user : userMapper.selectUser()) {
            System.out.println(user);
        }
    }
}
  1. 编写数据源配置
  2. sqlSessionFactory
  3. sqlSessionTemplate
  4. 需要给接口加实现类【】
  5. 将自己写的实现类，注入到Spring中
  6. 测试

13. 声明式事务

  1. 回顾事务
    • 把一组业务当成一个业务来做；要么成功 要么都失败
    • 事务在项目开发中 十分的重要，涉及到数据的一致性，不能马虎
    • 确保完整性和一致性

事务ACID原则：

  • 原子性
  • 一致性
  • 隔离性
    • 多个业务可能操作同一个资源，防止暑假损坏
  • 持久性
    • 事务一旦提交，无论系统发生什么问题，结果都不会被影响，被持久化的写到存储器中！
  1. spring 中的事务管理
    • 声明式事务： AOP
    • 编程式事务 ： 需要在代码中，进行事务的管理

思考：
为什么需要事务？
* 如果不配置事务，可能存在数据提交不一致的情况下
* 如果我们不在Spring中配置声明式事务，我们就需要在代码中手动配置事务
* 事务在项目的开发中十分重要，涉及到数据的一致性和完整性问题，不容马虎

尚硅谷Spring笔记
04-11
尚硅谷Spring笔记
spring笔记
04-12
Spring 笔记 Spring 是 Java 企业版（Java EE）应用程序的框架，提供了结构化的配置文件，实现了控制反转（IoC）和面向切面编程（AOP），支持表现层、业务逻辑层和持久层。Spring 的核心是 IoC 和 AOP，能够与主流...
Spring 学习笔记
低吟不作语的博客
09-03 1493
Spring 是一个企业级 J2EE 应用开发一站式解决方案，其提供的功能贯穿了项目开发的表现层、业务层和持久化层，同时，Spring 可以和其他应用框架无缝整合轻量：Spring 是一个轻量级的框架，其核心 JAR 包的大小均为 1MB 左右。从系统的资源使用上来说，Spring 也是一个轻量级的框架，在其运行期间只需少量的操作系统资源便能稳定运行。
Spring笔记汇总
studyeglish的博客
05-24 540
学习参考 引言 第一个Spring Spring5.x与日志框架的整合 注入（injection） Set注入详解 构造注入 反转控制 与 依赖注入
黑马程序员SSM_Spring笔记(自用)
qq_62656514的博客
10-12 4674
黑马程序员SSM_Spring笔记(自用)
【狂神说】——Spring笔记（全）
java小豪的博客
06-28 7658
Spring : 春天 —>给软件行业带来了春天2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。
Spring学习笔记
徐小陌的博客
05-27 2389
Spring学习笔记 第一部分：Spring 概述 1.1 Spring 简介 轻量级开源框架 核心是IOC和AOP 使⽤最多的 Java EE 企业应⽤开源框架 1.2 Spring 发展历程 EJB->Expert One-to-One J2EE Design and Development论文->Spring 1.3 Spring 的优势 ⽅便解耦，简化开发 通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进⾏控制，避免硬编码所造成的 过度程序耦合。⽤户也不
Spring笔记总结
qq_43720467的博客
01-03 602
Spring学习笔记总结 一，第一个spring程序(控制反转) 1.0在pow文件中导入依赖spring四个核心包 <!-- https://mvnrepository.com/artifact/org.springframework/spring-context --> <dependency> <groupId>org.springframework</groupId> <artifactId>
狂神说spring笔记
热门推荐
Frank---7的博客
12-31 6万+
B站 https://www.bilibili.com/video/BV1WE411d7Dv 狂神说Spring01：概述及IOC理论推导 https://mp.weixin.qq.com/s/VM6INdNB_hNfXCMq3UZgTQ 狂神说Spring02：快速上手Spring https://mp.weixin.qq.com/s/Sa39ulmHpNFJ9u48rwCG7A 狂神说Spring03：依赖注入（DI）https://mp.weixin.qq.com/s/Nf-cYENenoZpXqDj
Spring Security笔记
The_good_boy的博客
01-12 782
1.1Spring Security是 Spring提供的安全认证服务的框架。SpringSecurity是Spring家族的一个安全框架, 简化我们开发里面的认证和授权过程SpringSecurity内部封装了Filter（只需要在web.xml容器中配置一个过滤器--代理过滤器，真实的过滤器在spring的容器中配置）链式模式常见的安全框架：（1）Spring的 SpringSecurity；（2）Apache的Shiro。
韩顺平Spring笔记
04-30
《韩顺平Spring笔记》是针对Java开发人员深入学习Spring框架的重要参考资料，它源自知名IT教育专家韩顺平的Spring教程。这篇笔记详尽地记录了Spring的核心概念、使用方法和实战技巧，对于理解Spring的工作原理和提升...
SpringBoot手写操作日志自动记录功能
2403_87729201的博客
08-10 382
本文介绍了基于SpringAOP的操作日志自动记录方案。通过自定义@LogAnnotation注解和切面编程，实现业务方法零侵入的日志记录功能。方案包含数据库表设计（sys_log）、自定义注解定义、核心切面实现（LogAspect）及配套工具类（HttpContextUtil、IPUtil）。使用时只需在Controller方法上添加注解，切面会自动记录操作人、方法信息、参数、耗时等数据并存入数据库。该方案解决了手动记录日志的繁琐问题，提供完整的操作审计能力，执行流程涵盖请求处理全过程。
【SpringBoot系列-02】自动配置机制源码剖析
最新发布
专注后端技术架构，AI技术分享
08-13 145
Spring Boot自动配置机制深度解析：通过@SpringBootApplication注解中的@EnableAutoConfiguration启动自动配置流程，核心由AutoConfigurationImportSelector实现。该选择器从META-INF/spring.factories加载候选配置类，经过去重、排除处理、条件过滤等步骤（包括@ConditionalOnClass等条件注解的评估），最终筛选出符合条件的配置类注册到Spring容器。整个过程体现了约定优于配置的设计理念，开发者可通
spring-boot-starter-data-redis 与 org.redisson 区别 联系
惊鸿一博
08-10 608
本文对比分析了Spring Boot中两种Redis操作框架：spring-boot-starter-data-redis和Redisson。前者是Spring官方提供的Redis数据访问抽象层，基于Lettuce/Jedis实现，提供RedisTemplate等基础操作，适合常规缓存和键值存储；后者是第三方高性能Redis客户端，提供分布式锁、队列、集合等高级功能。两者可以共存但职责不同，建议根据需求选择：仅需基础功能时使用Spring Data Redis；需要分布式功能时引入Redisson；若同时需
Java 反射技术：企业级开发框架Spring的 “隐形引擎“
qq_20294455的博客
08-10 668
摘要： Java反射技术是突破编译期限制的底层机制，通过Class对象实现运行时类操作。其核心应用包括框架依赖注入（如Spring）、动态代理和对象映射（如MyBatis），但伴随性能损耗和安全风险。优化策略涵盖反射对象缓存、字节码生成（CGLIB）和批量操作，同时需配合SecurityManager进行权限管控。开发者应遵循最小权限原则，结合严格测试确保代码安全。反射技术平衡了灵活性与封装性，是Java高级开发的核心技能，在框架设计与动态编程中持续发挥关键作用。
基于SpringBoot校园管理系统
2501_90968670的博客
08-13 497
校园管理系统是一个基于Spring Boot + Vue.js的全栈应用，专注于高校内部的多角色协作管理。系统实现了院校管理、单位管理、用户管理、通知推送、投票管理等功能模块，满足管理员、院校管理员、普通用户三类角色的不同操作需求。核心目标是提升校园管理效率，实现通知精准推送与数据可视化统计。
Spring IoC实现原理详解
Rockandrollman的博客
08-12 932
Spring IoC实现原理详解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值