Spring框架课堂笔记

1、spring

1.1 简介

spring 春天----给软件行业带来了春天

  • 2002年，spring前身interface 21框架

  • 2004年3月24号，spring框架诞生

  • Rod johnson，spring创始人

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

 

  • SSH：Struct2+Spring+Hibernate

  • SSM：SpringMvc + Spring + Mybatis

官网：https://spring.io/projects/spring-framework

官方下载地址：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>5.2.4.RELEASE</version>
 </dependency>
 <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
 <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-jdbc</artifactId>
     <version>5.2.4.RELEASE</version>
 </dependency>

1.2 优点

  • Spring是一个开源的免费的框架（容器）

  • Spring是一个轻量级的、非入侵式的框架

  • 控制反转{IOC}，面向切面编程（AOP）

  • 支持事务的处理，对框架整合的支持

 

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

1.3 Spring的组成

截图

1.4 扩展

在Spring的官网有这个介绍：现代化的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本质 控制反转 loC(Inversion of Control)，是一种设计思想，Dl(依赖注入)是实现loC的一种方法，也有人认为DI只是loC的另一种说法。没有loC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是︰获得依赖对象的方式反转了。

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

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

3. HelloSpring

Hello.java

 package com.kuang.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
         http://www.springframework.org/schema/beans/spring-beans.xsd">
 <!--    使用spring创建对象，在spring中这些都称之为bean
         类型 变量名 = new 类型();
         Hello hello = new Hello();
         id = 变量名
         class = new 的对象
         property = 相当于给对象中的属性设置一个值
 -->
     <bean id="hello" class="com.kuang.pojo.Hello">
         <property name="str" value="Spring"></property>
     </bean>
 ​
 </beans>
 ​

MyTest.java

 import com.kuang.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对象的属性是怎么设置的? hello对象的属性是由Spring容器设置的

这个过程就叫控制反转:

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

反转:程序本身不创建对象，而变成被动的接收对象．

依赖注入:就是利用set方法来进行注入的.

IOC是一种编程思想,由主动的缤程变成被动的接收.

可以通过newClassPathXmlApplicationcontext去浏览一下底层源码． OK，到了现在，我们彻底不用再程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓的loc.一句话搞定;对象由Spring来创建，管理，装配!

4. IOC创建对象的方式

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

  2. 假设我们要使用有参构造创建对象

    1. 下标赋值

       <!--1. 下标赋值    -->
       <bean id="user" class="com.kuang.pojo.User">
           <constructor-arg index="0" value="kuangshenshuo"></constructor-arg>
       </bean>

    2. 类型赋值

       <!--2. 通过类型创建不建议使用    -->
       <bean id="user" class="com.kuang.pojo.User">
           <constructor-arg type="java.lang.String" value="qinjiangshuo"></constructor-arg>
       </bean>

    3. 参数名

       <!--3. 直接通过参数名 -->
       <bean id="user" class="com.kuang.pojo.User">
           <constructor-arg name="name" value="qinjiangshuo"></constructor-arg>
       </bean>

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

5. Spring配置

5.1 别名

 <!--    别名，如果添加了别名，我们可用别名-->
 <alias name="user" alias="asdvcda"></alias>

5.2 Bean的配置

 <!--
 id:bean的唯一标识符，也就是我们学的对象名
 class：bean对象所对应的权限命名：包名+类型
 name：也是别名,而且name可以取多个别名
 -->
 <bean id="userT" class="com.kuang.pojo.UserT" name="u2,user2;u4">
     <property name="name" value="西部开源"></property>
 </bean>

5.3 import

import一般用于团队开发使用，可以将多个配置文件导入合并为一个

假设现在项目中有多个人开发，这三个人负责不同的类开发，不同的类需要注册在不同的bean当中

用import将所有人的beans.xml合并为总的

  • 张三

  • 李四

  • 王五

  • applicationContext.xml

 <import resource="beans.xml"></import>
 <import resource="beans2.xml"></import>
 <import resource="beans3.xml"></import>

6. DI依赖注入

6.1 构造器注入

前面已经说过

6.2 Set方式注入[重点]

  • 依赖注入：Set注入

    • 依赖：bean对象的创建依赖于容器

    • 注入：bean对象中的所有属性，由容器来注入

 

【环境搭建】

  1. 复杂类型

     package com.kuang.pojo;
     ​
     public class Address {
         private String address;
     ​
         public String getAddress() {
             return address;
         }
     ​
         public void setAddress(String address) {
             this.address = address;
         }
     }

  2. 真实测试对象

 private String name;
 private Address address;
 private String[] books;
 private List<String> hobbies;
 private Map<String,String> card;
 private Set<String > games;
 private Properties info;
 private String wife;

  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="student" class="com.kuang.pojo.Student">
     <!--        1. 普通值注入，value-->
             <property name="name" value="宋晨旭"></property>
         </bean>
     </beans>
     ​

  2. 测试类

     import com.kuang.pojo.Student;
     import org.springframework.context.ApplicationContext;
     import org.springframework.context.support.ClassPathXmlApplicationContext;
     ​
     public class MyTest {
         public static void main(String[] args) {
             ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
             Student student = (Student) context.getBean("student");
             System.out.println(student.getName());
             //System.out.println(student.getAddress());
         }
     }

  3. 完善注入信息

     <bean id="student" class="com.kuang.pojo.Student">
     <!--        1. 普通值注入，value-->
             <property name="name" value="宋晨旭"></property>
     ​
             <!--2. bean注入，ref:引用spring容器中创建好的对象-->
             <property name="address" ref="address"></property>
     ​
             <!--3. 数组注入，array-->
             <property name="books">
                 <array>
                     <value>红楼梦</value>
                     <value>西游记</value>
                     <value>水浒传</value>
                     <value>三国演义</value>
                 </array>
             </property>
     ​
             <!--4. list注入，list-->
             <property name="hobbies">
                 <list>
                     <value>听歌</value>
                     <value>玩游戏</value>
                     <value>看电影</value>
                 </list>
             </property>
     ​
             <!--5. map注入，map-->
             <property name="card">
                 <map>
                     <entry key="身份证" value="1234567823"></entry>
                     <entry key="银行卡" value="12345562315677"></entry>
                 </map>
             </property>
     ​
             <!--6. set注入，set-->
             <property name="games">
                 <set>
                     <value>LOL</value>
                     <value>COC</value>
                     <value>BOB</value>
                 </set>
             </property>
     ​
             <!--7. null注入-->
             <property name="wife">
                 <null></null>
             </property>
     ​
             <!--8. Properties注入-->
             <property name="info">
                 <props>
                     <prop key="学号">202037515</prop>
                     <prop key="性别">男</prop>
                     <prop key="学名">小晨</prop>
                 </props>
             </property>
         </bean>
     ​
         <bean id="address" class="com.kuang.pojo.Address">
             <property name="address" value="河南"></property>
         </bean>
     </beans>
     ​
 public static void main(String[] args) {
     ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
     Student student = (Student) context.getBean("student");
     /*
     * Student{
     * name='宋晨旭',
     * address=Address{address='河南'},
     * books=[红楼梦, 西游记, 水浒传, 三国演义],
     * hobbies=[听歌, 玩游戏, 看电影],
     * card={身份证=1234567823,银行卡=12345562315677},
     * games=[LOL, COC, BOB],
     * info={学号=202037515, 学名=小晨, 性别=男},
     * wife='null'}
      * */
     System.out.println(student.toString());
 }

6.3 拓展方式注入

我们可以使用p命名空间和c命名空间进行注入

官方解释：

image-20220118183032279

使用：

 <?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
         http://www.springframework.org/schema/beans/spring-beans.xsd">
 <!--p命名空间注入。可以直接注入属性的值，property-->
     <bean id="user" class="com.kuang.pojo.User" p:name="宋晨旭" p:age="18"></bean>
 <!--C命名空间注入，通过构造器注入，construct-args-->
     <bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="狂神"></bean>
 </beans>
 ​

测试：

 public void test2(){
     ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
     User user = context.getBean("user2",User.class);
     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的作用域

image-20220118183614721

  1. 代理模式（Spring默认机制）

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

  2. 原型模式

    每次从容器中get的时候，都会产生一个新对象

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

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

7. Bean的自动装配

  • 自动装配是Spring满足bean依赖一种方式

  • Spring会在上下文中自动寻找bean，并自动给bean装配属性

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

  1. 在xml中显示的配置

  2. 在java中显示的配置

  3. 隐式的自动装配【重要】

 

7.1 测试

环境搭建：1个人有2个宠物

 <bean id="people" class="com.kuang.pojo.People">
     <property name="name" value="宋晨旭"></property>
     <property name="cat" ref="cat"></property>
     <property name="dog" ref="dog"></property>
 </bean>

7.2 ByName自动装配

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

7.3 ByType自动装配

 <!--byType：会自动在容器上下文中查找，和自己对象属性类型相同的bean id，只能类型全局唯一-->
 <bean id="people" class="com.kuang.pojo.People" autowire="byType">
     <property name="name" value="宋晨旭"></property>
 </bean>

小结：

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

  • bytype，需要保证所有的bean的class唯一，并且这个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>

    @Autowaired(最常用)

    直接在属性上使用即可，也可以在set方式上使用

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

    科普：

     @Nullable  字段标记了这个注解，说明这个字段可以为null
     //如果显式定义了Autowired得required得属性为false，说明这个对象可以为null，否则不允许为null
     public @interface Autowired {
         boolean required() default true;
     }
 //如果显式定义了Autowired得required得属性为false，说明这个对象可以为null，否则不允许为null
 @Autowired(required = false)
 private Dog dog;

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

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

@Resource注解

 //可以指定
 @Resource(name = "dog2")
 private Dog dog;
 //cat需要保持唯一性
 @Resource
 private Cat cat;
 private String name;

小结：@Resource @Autowired得区别：

  • 都是用来自动装配的，都可以放在属性字段上

  • @Autowired通过bytype的方式实现，且必须要求这个对象实现【常用】，如果Autowired不唯一装配属性，使用@Qualifier(value = "xxx")

  • @Resource默认通过byname方式实现，如果找不到名字，则通过bytype实现，如果两个都找不到的情况下，就报错【常用】

  • 执行顺序不同：@Autowired通过bytype的方式实现 @Resource默认通过byname方式实现

 

注解说明

  • @Autowired通过bytype的方式实现，且必须要求这个对象实现【常用】，如果Autowired不唯一装配属性，使用@Qualifier(value = "xxx")

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

  • @Resource默认通过byname方式实现，如果找不到名字，则通过bytype实现，如果两个都找不到的情况下，就报错【常用】

  • @Component 组件，放在类上，说明这个类被Spring管理了，就是bean

8. 使用注解开发

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

image-20220119142854393

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

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

 

  1. bean

     

  2. 属性如何注入

     package com.kuang.pojo;
     ​
     import org.springframework.beans.factory.annotation.Value;
     import org.springframework.stereotype.Component;
     ​
     //等价于    bean id="user" class="com.kuang.pojo.User"
     //@Component 组件
     @Component
     public class User {
         //相当于 <property name="name" value="宋晨旭/>
         @Value("宋晨旭")
         public String name;
     ​
         public void setName(String name) {
             this.name = name;福
         }
     }

     

  3. 衍生的注解

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

     

    • dao【@Repository】

    • service【@Service】

    • controller【@Controller】

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

  4. 自动装配注解

     - @Autowired通过bytype的方式实现，且必须要求这个对象实现【常用】，如果Autowired不唯一装配属性，使用@Qualifier(value = "xxx")
     - @Nullable 字段标记了这个注解，说明这个字段可以为null
     - @Resource默认通过byname方式实现，如果找不到名字，则通过bytype实现，如果两个都找不到的情况下，就报错【常用】

     

  5. 作用域

     @Component
     @Scope("singleton")
     public class User {
         //相当于 <property name="name" value="宋晨旭/>
         @Value("宋晨旭")
         public String name;
     ​
         public void setName(String name) {
             this.name = name;
         }
     }

     

  6. 小结

    xml与注解

    • xml 更加万能，适用于任何场合，维护简单方便

    • 注解 不是自己得类使用不了，维护相对复杂

    xml与注解最佳实践

    • xml用来管理bean

    • 注解只用来属性注入

    • 我们在使用的过程中，只需要注意一个问题：必须让注解生效，就需要开启注解得支持

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

       

9. 使用Java的方式配置Spring

我们现在要完全不使用Spring得xml配置了，全权交给Java来做

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

image-20220119152607384

实体类

 package com.kuang.pojo;
 ​
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;
 ​
 //这个注解的意思，就是说明这个类被Spring接管了，注册到了容器中
 @Component
 public class User {
     @Value("scx")//属性注入值
     private String name;
 ​
 ​
     public String getName() {
         return name;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
     @Override
     public String toString() {
         return "User{" +
                 "name='" + name + '\'' +
                 '}';
     }
 ​
 }
 ​

 

 

配置文件

 package com.kuang.config;
 ​
 ​
 import com.kuang.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;
 ​
 @Configuration
 //这个也会被spring容器托管，注册到容器中，因为它本来就是一个component//
 // @Configuration代表这是一个配置类，就和我们之前看到的beans.xml一样的
 @ComponentScan("com.kuang.pojo")
 @Import(MyConfig2.class)
 public class MyConfig {
 ​
     //注册一个bean，就相当于我们之前写的一个bean标签
     // id ： 这个方法的名字
     //class ： 这个方法的返回值
     @Bean
     public User user(){
         return new User();//就是返回要注入到bean的对象
     }
 }
 ​

 

测试类

 import com.kuang.config.MyConfig;
 import com.kuang.pojo.User;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 ​
 public class MyTest {
     public static void main(String[] args) {
 ​
         //如果完全使用了配置类方式去做，我们就只能通过AnnotationConfigApplicationContext 上下文来获取容器，通过配置类的class对象加载
         ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
         User getUser = context.getBean("user",User.class);
         System.out.println(getUser.getName());
 ​
 ​
     }
 }

 

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

10. AOP代理模式

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

代理模式的分类：

  • 静态代理

  • 动态代理

image-20220119172258433

10.1 静态代理

角色分析：

  • 抽象角色：一般会使用接口或者抽象类来解决

  • 真实角色：被代理的角色

  • 代理角色：代理真实角色，代理真实角色后，一般会做一些附属操作

  • 客户：访问代理对象的人

 

代码步骤：

  1. 接口

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

     

  2. 真实角色

     package com.kuang.demo01;
     ​
     //房东
     public class Host implements Rent{
         public void rent(){
             System.out.println("房东要出租房子");
         }
     ​
     }

     

  3. 代理角色

     package com.kuang.demo01;
     ​
     public class Proxy implements Rent{
     ​
     ​
         private Host host;
     ​
         public Proxy() {
         }
     ​
         public Proxy(Host host) {
             this.host = host;
         }
     ​
         @Override
         public void rent() {
             host.rent();
             seeHouse();
             hetong();
             fare();
         }
     ​
         //看房
         public void seeHouse(){
             System.out.println("中介带你看房");
         }
     ​
         //合同
         public void hetong(){
             System.out.println("签合同");
         }
     ​
         //收中介费
         public void fare(){
             System.out.println("收中介费");
         }
     ​
     }

     

  4. 客户端访问代理角色

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

     

 

 

代理模式的好处：

  • 可以使真实角色的操作更加纯粹，不用去关注一些公共的业务

  • 公共业务就交给了代理角色，实现了业务的分工

  • 公共业务发生扩展的时候，方便集中管理

缺点：

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

10.2 加深理解

聊聊Aop，代码对应spring-08-demo02

image-20220120121943833

10.3 动态代理

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

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

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

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

    • 基于类---cglib

    • Java字节码实现：javasist

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

动态代理的好处：

  • 可以使真实角色的操作更加纯粹，不用去关注一些公共的业务

  • 公共业务就交给了代理角色，实现了业务的分工

  • 公共业务发生扩展的时候，方便集中管理

  • 一个动态代理类代理的是一个接口，一般就是对应的一类业务

  • 一个动态代理类，可以代理多个类，只要是实现了同一个接口即可

11. AOP

11.1 什么是AOP

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

image-20220120194411806

11.2 AOP在Spring中的作用

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

  • 横切关注点:跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等....

  • 切面（ASPECT)︰横切关注点被模块化的特殊对象。即，它是一个类。

  • 通知(Advice):切面必须要完成的工作。即，它是类中的一个方法。·目标（Target):被通知对象。

  • 代理(Proxy)︰向目标对象应用通知之后创建的对象。

  • 切入点(PointCut):切面通知执行的“地点"的定义。

  • 连接点(JointPoint):与切入点匹配的执行点。

image-20220120194731481

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

image-20220120194957749

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

11.3 使用Spring实现AOP

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

 <dependency>
     <groupId>org.assertj</groupId>
     <artifactId>assertj-core</artifactId>
     <version>3.21.0</version>
 </dependency>

 

image-20220121161856085

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

 <!--    方式一：使用原生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>
         <aop:advisor advice-ref="afterlog" pointcut-ref="pointcut"></aop:advisor>
     </aop:config>

 

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

 <!--    方式二：自定义类-->
 <bean id="diy" class="com.kuang.diy.DiyPointcut"></bean>
 <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:before>
         <aop:after method="after" pointcut-ref="point"></aop:after>
         <aop:after method="middle" pointcut-ref="point"></aop:after>
     </aop:aspect>
 </aop:config>

 

方式三：使用注解实现

 //方式三：使用注解方式实现AOP
 @Aspect //标注这个类是一个切面
 public class AnnoationPointDiy {
     @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("========环绕后============");
     }
 }
 ​

 

 <!--方式三-->
 <bean id="diy" class="com.kuang.diy.AnnoationPointDiy"></bean>
 <!--    开启注解支持   JDK(默认 proxy-target-class="false")   cglib  proxy-target-class="true"-->
 <aop:aspectj-autoproxy proxy-target-class="false"/>

12. 整合Mybatis

步骤：

  1. 导入相关jar包

    • junit

    • mybatis

    • mysql数据库

    • spring相关

    • aop织入

    • mybatis-spring【new】

     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-webmvc</artifactId>
         <version>5.2.4.RELEASE</version>
     </dependency>
     <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>4.12</version>
     </dependency>
     <dependency>
         <groupId>org.aspectj</groupId>
         <artifactId>aspectjweaver</artifactId>
         <version>1.9.7</version>
     </dependency>
     ​
     <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
         <version>8.0.24</version>
     </dependency>
     ​
     <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
     <dependency>
         <groupId>org.mybatis</groupId>
         <artifactId>mybatis</artifactId>
         <version>3.5.9</version>
     </dependency>
     ​
     ​
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-webmvc</artifactId>
         <version>5.2.4.RELEASE</version>
     </dependency>
     ​
     <!--        Spring操作数据库的话，还需要spring-jdbc-->
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-jdbc</artifactId>
         <version>5.3.15</version>
     </dependency>
     ​
     ​
     <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
     <dependency>
         <groupId>org.mybatis</groupId>
         <artifactId>mybatis-spring</artifactId>
         <version>2.0.6</version>
     </dependency>

     

  2. 编写配置文件

  3. 测试

12.1 回忆Mybatis

  1. 编写实体类

  2. 编写核心配置文件

  3. 编写接口

  4. 编写Mapper.xml

  5. 测试

12.2 Mybatis-Spring

  1. 编写数据源配置

  2. sqlSessionFactory

  3. sqlSessionTemplate

  4. 需要给接口加实现类【】

  5. 将自己写的实现类，注入到Spring种

  6. 测试使用即可

老方法：手动注入

 package com.kuang.mapper;
 ​
 import com.kuang.pojo.User;
 import org.mybatis.spring.SqlSessionTemplate;
 ​
 import java.util.List;
 ​
 public class UserMapperImpl implements UserMapper{
     //原来我们所有的操作，都是用sqlSession来执行，现在都使用sqlSessionTemplate
     private SqlSessionTemplate sqlSession;
 ​
     public void setSqlSession(SqlSessionTemplate sqlSession) {
         this.sqlSession = sqlSession;
     }
 ​
     @Override
     public List<User> selectUser() {
         return sqlSession.getMapper(UserMapper.class).selectUser();
     }
 }
 ​

 

 

 

 <?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的数据源替换Mybatis的配置 c3p0 dbcp druid
     我们这里使用的是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?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/kuang/mapper/*.xml"/>
 ​
     </bean>
 <!--    SqlSessionTemplate就是sqlSession-->
     <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
 <!--        只能使用构造器注入sqlSessionFactory，因为他没有set方法-->
         <constructor-arg index="0" ref="sqlSessionFactory"/>
     </bean>
 ​
     <bean id="userMapper" class="com.kuang.mapper.UserMapperImpl">
         <property name="sqlSession" ref="sqlSession"/>
     </bean>
     
     <bean id="userMapper2" class="com.kuang.mapper.UserMapperImpl2">
         <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
     </bean>
 ​
 ​
 </beans>

简化步骤方式：SqlSessionDaoSupport

 package com.kuang.mapper;
 ​
 import com.kuang.pojo.User;
 import org.apache.ibatis.session.SqlSession;
 import org.mybatis.spring.support.SqlSessionDaoSupport;
 ​
 import java.util.List;
 ​
 public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{
     @Override
     public List<User> selectUser() {
         SqlSession sqlSession = getSqlSession();
         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
         return mapper.selectUser();
     }
 }

13. 声明式事务

13.1 回顾事务

  • 一组业务要么都成功，要么都失败

  • 事务在项目开发中十分重要，涉及到事务的一致性问题，不能马虎

  • 确保完整性和一致性

 

事务ACID原则：

  • 原子性

  • 一致性

  • 隔离性

    • 多个事务可能操作同一个资源，防止数据破坏

  • 持久性

    • 事务一旦提交，无论系统发生什么问题，结果都不会发生改变，被持久化的写到存储器中

13.2 Spring中的事务管理

  • 声明式事务：AOP

  • 编程式事务：需要在代码中，进行事务的管理

  •  
posted @   Bilia  阅读(350)  评论(0)  编辑  收藏  举报
相关博文：
· MyBatis课堂笔记
· 注解与反射
· Spring框架
· Spring
· Spring 基础
阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 记一次.NET内存居高不下排查解决与启示
· DeepSeek 开源周回顾「GitHub 热点速览」
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
点击右上角即可分享
微信分享提示