文章目录
Spring
1、Spring简介
1.1、搭建准备
SSM：SpringMvc + Spring + Mybatis
官网：https://spring.io/projects/spring-framework#overview
Github: https://github.com/spring-projects/spring-framework
maven spring：
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.23</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.23</version>
</dependency>
为了方便建我们的子项目，我们可以把src包删掉，新建子module来方便我们学习
1.2、Spring的作用
- spring是一个开源的免费的框架。（容器）
- spring是一个轻量级的、非侵入式的框架。
- 控制反转（IOC），面向切面编程（AOP）
- 支持事务处理对框架整合支持！
总结：Spring就是一个轻量级控制反转（IOC）和面向切面编程的框架（AOP）！
1.3、Spring的组成
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cKf8h1cM-1665541860706)(img/image-20221008155245733.png)]](https://i-blog.csdnimg.cn/blog_migrate/d443b748188af510dd37f1b0f1a7ca0c.png)
1.4、扩展
在Spring的官网介绍：现代化的java开发，说白了就是基于Spring的开发！
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AK64lgQP-1665541860708)(img/image-20221008155534749.png)]](https://i-blog.csdnimg.cn/blog_migrate/a65cf953fbbf4adb59a5f16916599c42.png)
- SpringBoot
- 一个快速开发的脚手架
- 基于SpringBoot可以快速的开发单个微服务
- 约定大于配置
- SpringCloud
- SpringCloud是基于SpringBoot实现的
因为现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring及SpringMVC！启承上启下的作用！
弊端：发展了太久之后，违背了原来的理念！配置十分繁琐，人称：”配置地狱“
2、IOC理论推导
- UserDao 接口
- UserDaoImpl 实现类
- UserService 业务接口
- UserServiceImpl 业务实现类
在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改源代码！如果程序代码量十分大，修改一次的成本代价十分昂贵！
我们使用一个Set接口实现，已经发生了革命性变化！
//private UserDao userDao = new UserDaoImpl(); //调用dao层
private UserDao userDao;
//利用set进行动态实现值的注入！
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void getUser(){
userDao.getUser();
}
public class MyTest {
public static void main(String[] args) {
//用户实际调用的是业务层，dao层他们不需要接触
UserServiceImpl userService = new UserServiceImpl();
// ((UserServiceImpl) userService).setUserDao(new UserDaoImpl());
userService.setUserDao(new UserDaoImpl());
userService.getUser();
}
}
- 之前：程序是主动创建对象！控制权在程序员手上！（控制反转，思想转换）
- 使用set注入后，程序不再具有主动性，而是变成了被动的接受对象！
2.1、IOC本质
控制反转(inversion of control), 是一种设计思想,DI(dependency injection依赖注入)是IOC的一种方法.未使用IOC的程序中,我们使用面向对象编程,对象的创建和对象之间的依赖关系完全硬编码在程序中,对象的创建是由程序自己控制的.控制反转就是将对象的创建转移给了第三方.
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。
3、HelloSpring（第一个程序）
3.1、思想
只需要通过下面的beans.xml文件中 ref="***"里面的对象，就能够切换功能输出，这样我们写的代码就可以不用去更改了，并且让用户只需要更改xml中相对应的值就可以完成所需业务需求，达到了IOC控制反转的思想:交给用户
<!-- 使用spring来创建对象，在spring这些都称为Bean
类型 变量名 = new 类型();
Hello hello = new Hello();
id = 变量名
class = new 对象
property 相当于给对象中的属性设置一个值！
bean = 对象 new Hello();
-->
<bean id="mysql" class="com.heze.dao.UserMysqlImpl"/>
<bean id="oracle" class="com.heze.dao.UserOracleImpl"/>
<bean id="UserServiceImpl" class="com.heze.service.UserServiceImpl">
<property name="userDao" ref="mysql"/>
</bean>
<!-- ref:应用spring容器中创建好的对象
value:具体的值，基本数据类型！
-->
//获取AppLicationContext; 拿到spring容器
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//从容器中取出数据get
UserServiceImpl userService = (UserServiceImpl)context.getBean("UserServiceImpl");
userService.getUser();
3.2、简单总结
使用Spring，我们可以彻底不用再去程序中改动了，要实现不同的操作，只需要在xml配置文件中进行修改所谓的IOC。
一句话搞定：对象由Spring 来创建，管理，装配！
4、IOC创建对象的方式
1.使用无参构造创建对象，默认！
2.假设我们要使用有参构造创建对象。
-
下标赋值
<bean id="user" class="com.heze.pojo.User"> <!-- 第一种：下标赋值--> <constructor-arg index="0" value="何泽"/> </bean> -
类型
<!-- 第二种方式：通过类型创建，不建议使用！--> <bean id="user" class="com.heze.pojo.User"> <constructor-arg type="java.lang.String" value="何泽"/> </bean> -
参数名
<!-- 第三种方式：直接通过参数名来设置--> <bean id="user" class="com.heze.pojo.User"> <constructor-arg name="name" value="何泽"/> </bean>
总结：在配置文件加载的时候，容器中管理的对象就已经被创建了，就是bean
5、Spring配置
5.1、别名
<!-- 别名，如果添加了别名，我们也可以使用别名获取到这个对象-->
<alias name="user" alias="user2"/>
5.2、Bean的配置
<!--
id：bean 的唯一标识符，也就是相当于我们学的对象名
class：bean 对象所对应的权限命名： 包名 + 类型
name: 也是别名，而且name可以同时取多个别名(别名功能更加强大)
-->
<bean id="user" class="com.heze.pojo.User" name="user3">
<property name="name" value="微微"/>
</bean>
5.3、import
这个import，一般用于团队开发使用，他可以将多个配置文件，导入合并为一个
假设，现在项目中有多个人开发，负责不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的applicationContext.xml；
使用的时候，直接使用总的配置就可以了，这时候就需要improt进行导入整合
<import resource="beans.xml"/>
<import resource="beans2.xml"/>
6、依赖注入DI
6.1、构造器注入
前面已经说过：即constructor-arg这个标签属性
6.2、Set方式注入【重点】
- 依赖注入：Set注入！
- 依赖：bean对象的创建依赖于容器！
- 注入：bean对象中的所有属性，由容器来注入
【环境搭建】
-
复杂类型
public class Address { private String address; public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } } -
真实测试对象
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; } -
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-3.0.xsd"> <bean id="student" class="com.heze.pojo.Student"> <!-- 第一种：普通值注入，value--> <property name="name" value="微微"/> </bean> </beans> -
测试类
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.getAddress()); } }
完善注入信息
<bean id="address" class="com.heze.pojo.Address"/>
<bean id="student" class="com.heze.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="hobbys">
<list>
<value>听歌</value>
<value>敲代码</value>
<value>看电影</value>
<value>旅游</value>
</list>
</property>
<!-- Map注入-->
<property name="card">
<map>
<entry key="身份证" value="12212121212"/>
<entry key="银行卡" value="212121243434"/>
</map>
</property>
<!-- Set注入-->
<property name="games">
<set>
<value>LOL</value>
<value>COC</value>
<value>BOB</value>
</set>
</property>
<!-- null注入-->
<property name="wife">
<null/>
</property>
<!-- properties-->
<property name="info">
<props>
<prop key="学号">20200403</prop>
<prop key="性别">男</prop>
<prop key="username">root</prop>
<prop key="password">123456</prop>
</props>
</property>
</bean>
6.3、拓展方式注入
注意：单独放一个这个标签程序会报错
<bean></bean>
我们可以使用p命名空间和c命名空间进行注入
使用测试：
<!-- p命名空间注入，可以直接注入属性的值：properties-->
<bean id="user" class="com.heze.pojo.User" p:name="微微" p:age="18"/>
<!-- c命名空间注入，通过构造器注入：construct-args-->
<bean id="user2" class="com.heze.pojo.User" c:age="18" c:name="微微"/>
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
User user = context.getBean("user2", User.class);
System.out.println(user);
}
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9ZvoUFHx-1665541860709)(img/image-20221010104840411.png)]](https://i-blog.csdnimg.cn/blog_migrate/183f3702b7e098caac438b17888a12cb.png)
注意点：p命名和c命名空间，不能直接使用，需要导入xml约束！
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
6.4、bean的作用域
-
单例模式（Spring的默认机制）【面试：手写代码去实现】
<bean id="user2" class="com.heze.pojo.User" c:age="18" c:name="微微" scope="singleton"/>@Test public void test2(){ ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml"); User user = context.getBean("user2", User.class); User user2 = context.getBean("user2", User.class); System.out.println(user.hashCode()); System.out.println(user2.hashCode()); System.out.println(user == user2); }![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nOeIAtmk-1665541860709)(img/image-20221010110508260.png)]](https://i-blog.csdnimg.cn/blog_migrate/4e68b7c982b609aa0f83e51639140b9c.png)
-
原型模式
<bean id="user2" class="com.heze.pojo.User" c:age="18" c:name="微微" scope="prototype"/>@Test public void test2(){ ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml"); User user = context.getBean("user2", User.class); User user2 = context.getBean("user2", User.class); System.out.println(user.hashCode()); System.out.println(user2.hashCode()); System.out.println(user == user2); }![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s6zLzLov-1665541860710)(img/image-20221010105838084.png)]](https://i-blog.csdnimg.cn/blog_migrate/53e738428091f4ebd826046eaffe3189.png)
-
其余的request，session，application，这些个只能在web开发中用到！
7、Bean的自动装配
- 自动装配是Spring满足bean依赖的一种方式
- Spring会在上下文中自动寻找，并自动给bean装配属性
在spring中有三种自动装配的方式
- 在xml中显示配置
- 在java中显示配置
- 隐式的自动装配bean【重点】
7.1、测试
环境搭建：一个人有两个宠物
7.2、ByName自动装配
<!-- byName: 会自动在容器中上下文查找，和自己对象set方法后面的值对应的bean id-->
<bean id="people" class="com.heze.pojo.People" autowire="byName">
<property name="name" value="微微"/>
<!-- <property name="dog" ref="dog"/>-->
<!-- <property name="cat" ref="cat"/>-->
</bean>
7.3、ByType自动配置
<bean id="cat" class="com.heze.pojo.Cat"/>
<bean id="dog1" class="com.heze.pojo.Dog"/>
<!-- byName: 会自动在容器中上下文查找，和自己对象set方法后面的值对应的bean id 限制：名字需相同-->
<!-- byType: 会自动在容器中上下文查找，和自己对象set方法后面类型相同的bean 限制：需要保证这个类型全局唯一-->
<bean id="people" class="com.heze.pojo.People" autowire="byType">
<property name="name" value="微微"/>
<!-- <property name="dog" ref="dog"/>-->
<!-- <property name="cat" ref="cat"/>-->
</bean>
小结：
- byName的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致
- byType的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致
7.4、使用注解自动装配【重要】
官方文档中介绍：使用注解开发比xml开发更好
要使用注解须知：
-
倒入约束
-
配置注解支持: 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 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:annotation-config/> </beans>-
@Autowired、@Qualifier
直接在属性上使用即可，也可以在set方式上面使用
//如果显示定义Autowired的required属性为false，说明这个对象可以为null，否则不允许为空 @Autowired(required = false) private Cat cat; @Autowired private Dog dog;使用Autowired我们可以不用编写Set方法了，前提是你这个自动装配的属性在IOC（Spirng）容器汇总存在，且符合名字byName！
如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以使用@Qualifier(value=“xxx”)去配置@Autowired的使用，指定一个唯一的bean对象注入！
@Autowired private Cat cat; @Autowired @Qualifier(value = "dog2") private Dog dog; -
@Resource
@Resource private Cat cat; @Resource(name = "dog2") private Dog dog;
小结：
@Resource和@Autowired的区别：
- 都是用来自动装配的，都可以放在属性字段上
- @Autowired通过byType方式实现，而且必须要求这个对象存在【常用】
- @Resource默认通过byName方式实现，如果找不到名字，则通过byType实现！如果两个都找不到，才报错
-
8、使用注解开发
在Spring4之后，要使用注解开发，必须保证aop的包导入！
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.23</version>
</dependency>
里面包含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">
</beans>
8.1 注解类型
-
@Autowired：自动通过类型、名字装配
如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value=“xxx”)
-
@Nullable：字段标记了这个注解，说明这个字段可以为null
-
@Resource：自动通过类型、名字装配
-
@Component：组件，放在类上，说明这个类被Spring管理了，就是bean
<!-- 指定要扫描的包，这个包下的注解就会生效--> <context:component-scan base-package="com.heze.pojo"/> <context:annotation-config/>衍生的注解
@Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层！
- dao 【@Repository】
- service【@Service】
- controller【@Controller】
这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean
-
@Value(“”)：设定简单属性的值
//等价于 <bean id="user" class="com.heze.pojo.User"/> //@Component 组件 @Component public class User { public String name; @Value("微微") public void setName(String name) { this.name = name; } } -
@Scope(“”)：作用域，可以设置为单例模式singleton或者原型模式prototype
@Scope("singleton")
小结：
xml与注解：
- xml：更加万能，适用于任何场合！维护简单方便
- 注解：不是自己的类用不了，维护相对复杂！
xml与注解最佳实践：
- xml用来管理bean；
- 注解只负责完成属性的注入；
- 我们在使用的过程中，只需要注意一个问题：必须让注解生效，就需要开启注解支持
9、使用Java的方式配置Spring
我们现在要完全不使用Spring的xml配置了，全权交给我们的java来做！
javaConfig是Spring的一个子项目，在Spring 4之后，它成为了一个核心功能
User.java实体类：
//这里这个注解的意思，就是说明这个类被spring接管了，注册到了容器中
@Component
public class User {
private String name;
public String getName() {
return name;
}
@Value("微微") //属性注入值
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
Myconfig.java配置类
package com.heze.config;
import com.heze.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 //代表这是一个配置类，相当于beans.xml,这个也会被Spring容器托管，注册到容器中，因为它本来就是一个@Component
@ComponentScan("com.heze.pojo")
@Import(MyConfig2.class)
public class MyConfig {
//注册一个bean，就相当于我们之前写的一个bean标签
//id = 方法名 class = 返回值
@Bean
public User getUser(){
return new User(); //返回要注入的bean的对象！
}
}
MyTest.java测试类
import com.heze.config.MyConfig;
import com.heze.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class MyTest {
@Test
public void test1(){
//如果完全使用了配置类方式去做，我们就只能通过AnnotationConfig 上下文来获取，通过配置类的class对象加载！
ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class); //ACA
User user = (User) context.getBean("getUser");
System.out.println(user);
}
}
这种纯Java的配置方式，在SpringBoot中随处可见！
10、代理模式
为什么要学习代理模式？ 因为这就是SpringAOP的底层！【SpringAOP 和 SpringMVC】
代理模式的分类：
-
静态代理
-
动态代理
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ejMMoZlu-1665541860710)(img/image-20221011063448848.png)]](https://i-blog.csdnimg.cn/blog_migrate/63a086ec828686463c46f0f12907bd70.png)
10.1、静态代理
角色分析：
- 抽象角色：一般会使用接口或者抽象类来解决
- 真实角色：被代理的角色
- 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
- 客户：访问代理对象的人！
代理类：在不改变原有代码的基础上，为真实角色增加一个代理类，来实现更多的需求。
代码步骤：
-
接口
//出租房子 public interface Rent { public void rent(); } -
真实角色
//房东 public class Host implements Rent{ @Override public void rent() { System.out.println("房东要出租房子!"); } } -
代理角色
//租房中介 public class Proxy implements Rent{ private Host host; //使用组合，不是继承 public Proxy() { } public Proxy(Host host) { this.host = host; } @Override public void rent() { host.rent(); seeHouse(); fare(); } //看房 public void seeHouse(){ System.out.println("中介带你看房"); } //收中介费 public void fare(){ System.out.println("收中介费"); } } -
客户端访问代理角色
//租客 public class Client { public static void main(String[] args) { //房东要租房子 Host host = new Host(); //代理，中介帮房东租房子，中介代理角色会有一些附属操作！ Proxy proxy = new Proxy(host); //你不用面对房东，直接找中介租房即可！ proxy.rent(); } } -
结果
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NV5yNe4N-1665541860711)(img/image-20221011070250871.png)]](https://i-blog.csdnimg.cn/blog_migrate/1246507d8639c92307da452e902ae073.png)
代理模式的好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共的业务也就交给代理角色！实现了业务的分工！
- 公共业务发生扩展的时候，方便集中管理！
缺点：
- 一个真实角色就会产生一个代理角色，代码量会翻倍~开发效率会变低
10.2、静态进阶
AOP
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AvpP2VID-1665541860711)(img/image-20221011073515412.png)]](https://i-blog.csdnimg.cn/blog_migrate/a865f39503a2548d5b2fff6ba33ca6f6.png)
10.3、动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的，不是我们直接写好的！
- 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口—JDK动态代理
- 基于类—cglib
- java字节码实现—javassist
需要了解两个类：Proxy，InvocationHandler
动态代理的好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共的业务也就交给代理角色！实现了业务的分工！
- 公共业务发生扩展的时候，方便集中管理！
- 一个动态代理类代理的是一个接口，一般就是对应的一类业务
- 一个动态代理类可以代理多个类，只要是实现了同一个接口即可
package com.heze.demo04;
import com.heze.demo03.Rent;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//用这个类，自动生成代理类！
public class ProxyInvocationHandler implements InvocationHandler {
//被代理的接口
private Object target;
public void setTarget(Object target) {
this.target = target;
}
//生成代理类
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
//处理代理实例，并返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//动态代理的本质，就是使用反射机制实现！
Object result = method.invoke(target, args);
log(method.getName());
return result;
}
public void log(String msg){
System.out.println("执行了" + msg+"方法");
}
}
package com.heze.demo04;
import com.heze.demo02.UserService;
import com.heze.demo02.UserServiceImpl;
public class Client {
public static void main(String[] args) {
//真实角色
UserServiceImpl userService = new UserServiceImpl();
//代理角色
ProxyInvocationHandler handler = new ProxyInvocationHandler();
handler.setTarget(userService);
//动态生成代理类
UserService proxy = (UserService) handler.getProxy();
proxy.delete();
}
}
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2iVixIX1-1665541860712)(img/image-20221011124306197.png)]](https://i-blog.csdnimg.cn/blog_migrate/c1d720689dedee47fff18b47bf48712a.png)
11、AOP
11.1、什么是AOP
AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MF9czBNv-1665541860713)(img/image-20221011125314462.png)]](https://i-blog.csdnimg.cn/blog_migrate/0ab2bbd3c0a918c642966e7828730945.png)
11.2、Aop在Spring中的作用
提供声明式事务；允许用户自定义切面
- 横切关注点:跨越应用程序多个模块的方法或功能.既是,与我们业务逻辑无关,但是我们需要关注的部分,就是横切关注点.如日志,安全,缓存,事务等…
- 切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。
- 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
- 目标（Target）：被通知对象。
- 代理（Proxy）：向目标对象应用通知之后创建的对象。
- 切入点（PointCut）：切面通知 执行的 “地点”的定义。
- 连接点（JointPoint）：与切入点匹配的执行点。
Aop在不改变原有的代码的情况下，去增加新的功能
11.3、使用Spring实现Aop
-
依赖
<dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.9.1</version> </dependency> -
方式一：使用Spring的AOP接口
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ndrMo608-1665541860713)(img/image-20221011163601992.png)]](https://i-blog.csdnimg.cn/blog_migrate/29e7c60d12cd310423875b1196805a9a.png)
<?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-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"> <!-- 注册bean--> <bean id="userService" class="com.heze.service.UserServiceImpl"/> <bean id="log" class="com.heze.log.Log"/> <bean id="afterLog" class="com.heze.log.AfterLog"/> <!-- 方式一：使用原生Spring API接口--> <!-- 配置aop:需要导入aop的约束--> <aop:config> <!-- 切入点:expression:表达式, execution(要执行的位置！*****)--> <aop:pointcut id="pointcut" expression="execution(* com.heze.service.UserServiceImpl.*(..))"/> <!-- 执行环绕增加！--> <aop:advisor advice-ref="log" pointcut-ref="pointcut"/> <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/> </aop:config> </beans> -
方式二：自定义来实现AOP
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pXHOn8I7-1665541860714)(img/image-20221011163745272.png)]](https://i-blog.csdnimg.cn/blog_migrate/21792d2c8a1506b9fe4a580e3cdd0fad.png)
<?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-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"> <!-- 注册bean--> <bean id="userService" class="com.heze.service.UserServiceImpl"/> <bean id="log" class="com.heze.log.Log"/> <bean id="afterLog" class="com.heze.log.AfterLog"/> <!-- 方式二：自定义类--> <bean id="diy" class="com.heze.diy.DiyPointCut"/> <aop:config> <!-- 自定义切面， ref 要应用的类--> <aop:aspect ref="diy"> <!-- 切入点--> <aop:pointcut id="point" expression="execution(* com.heze.service.UserServiceImpl.*(..))"/> <!-- 通知--> <aop:before method="before" pointcut-ref="point"/> <aop:after method="after" pointcut-ref="point"/> </aop:aspect> </aop:config> </beans>
-
方式三：使用注解实现
<!-- 方式三--> <bean id="annotationPointCut" class="com.heze.diy.AnnotationPointCut"/> <!-- 开启注解支持 JDK(默认) cglib--> <aop:aspectj-autoproxy/>package com.heze.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.heze.service.UserServiceImpl.*(..))") public void before(){ System.out.println("======方法执行前====="); } @After("execution(* com.heze.service.UserServiceImpl.*(..))") public void after(){ System.out.println("=======方法执行后====="); } //在环绕增强中，我们可以给定一个参数，代表我们要获取处理的切入的点 @Around("execution(* com.heze.service.UserServiceImpl.*(..))") public void around(ProceedingJoinPoint jp) throws Throwable { System.out.println("环绕前"); // Signature signature = jp.getSignature(); //获得签名 // System.out.println("signature" + signature); //执行方法 Object proceed = jp.proceed(); System.out.println("环绕后"); System.out.println(proceed); } }![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cgxV4LJl-1665541860715)(img/image-20221011165959031.png)]](https://i-blog.csdnimg.cn/blog_migrate/fa2fb002209e9ab8e9cac4eae8d2afd2.png)
12、整合Mybatis
步骤
-
导入相关的jar包
- junit
- mybatis
- mysql数据库
- spring相关的
- aop注入
- mybatis-spring【new】
<dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13</version> <scope>*</scope> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.30</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.3.23</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.3.23</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.9.1</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.7</version> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>RELEASE</version> <scope>compile</scope> </dependency> <!-- log4j--> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.12</version> </dependency> </dependencies> <!-- 在build中配置resources，来防止我们资源导出失败的问题--> <build> <resources> <resource> <directory>src/main/resources</directory> <includes> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>true</filtering> </resource> <resource> <directory>src/main/java</directory> <includes> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>true</filtering> </resource> </resources> </build> </project> -
编写配置文件
-
测试
12.1、回忆mybatis
-
编写实体类
package com.heze.pojo; import lombok.Data; @Data public class User { private int id; private String name; private String pwd; } -
编写配置文件
mybatis-config.xml
<?xml version="1.0" encoding="UTF8"?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <!-- 引入外部配置文件--> <properties resource="db.properties"></properties> <!-- 设置日志--> <settings> <!-- <setting name="logImpl" value="STDOUT_LOGGING"/>--> <setting name="logImpl" value="LOG4J"/> </settings> <!-- 可以给实体类起别名--> <typeAliases> <!-- <typeAlias type="com.heze.pojo.User" alias="User"/>--> <package name="com.heze.pojo"/> </typeAliases> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <property name="driver" value="${driver}"/> <property name="url" value="${url}"/> <property name="username" value="${username}"/> <property name="password" value="${password}"/> </dataSource> </environment> </environments> <mappers> <!-- <mapper resource="com/heze/dao/UserMapper.xml"/>--> <!-- 绑定接口--> <mapper class="com.heze.mapper.UserMapper"/> </mappers> </configuration>db.properties
driver=com.mysql.cj.jdbc.Driver url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai username = root password=123456log4j.properties
#???DEBUG????????console?file???????console?fiLe????????? log4j.rootLogger=DEBUG,console,file #?????????? log4j.appender.console = org.apache.log4j.ConsoleAppender log4j.appender.console.Target = System.out log4j.appender.console.Threshold=DEBUG log4j.appender.console.layout = org.apache.log4j.PatternLayout log4j.appender.console.layout.ConversionPattern=[%c]-%m%n #????????? log4j.appender.file = org.apache.log4j.RollingFileAppender log4j.appender.file.File=./log/heze.log #log4j.appender.file.MaxFilesize=10mb log4j.appender.file.Threshold=DEBUG log4j.appender.file.layout=org.apache.log4j.PatternLayout 1og4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n #?????? 1og4j.logger.org.mybatis=DEBUG log4j.logger.java.sql=DEBUG log4j.logger.java.sql.Statement=DEBUG log4j.logger.java.sql.ResultSet=DEBUG log4j.logger.java.sql.PreparedStatement=DEBUG -
编写接口
package com.heze.mapper; import com.heze.pojo.User; import java.util.List; public interface UserMapper { public List<User> selectUser(); } -
编写Mapper.xml
<?xml version="1.0" encoding="UTF8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.heze.mapper.UserMapper"> <select id="selectUser" resultType="user"> select * from mybatis.user; </select> </mapper> -
测试
import com.heze.mapper.UserMapper; import com.heze.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 java.io.IOException; import java.io.InputStream; import java.util.List; public class MyTest { @Test public void test1() throws IOException { String resources = "mybatis-config.xml"; InputStream in = Resources.getResourceAsStream(resources); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in); SqlSession sqlSession = sqlSessionFactory.openSession(true); UserMapper mapper = sqlSession.getMapper(UserMapper.class); List<User> userList = mapper.selectUser(); for (User user : userList) { System.out.println(user); } sqlSession.close(); } }
12.2、mybatis-spring
- 编写数据源
- SqlSessionFactory
- SqlSessionTemplate
- 需要给接口加实现类【】
- 将自己写的实现类，注入到Spring中
- 测试
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nZj9DQvk-1665541860716)(img/image-20221012084738331.png)]](https://i-blog.csdnimg.cn/blog_migrate/e98d3309d90207d754a35b21df4fcc74.png)
spring-dao.xml
<?xml version="1.0" encoding="UTF8"?>
<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-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.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&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai"/>
<property name="username" value="root"/>
<property name="password" value="@Heze128"/>
</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/heze/mapper/*.xml"/>
</bean>
<!-- SqlSessionTemplate：就是我们使用的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!-- 只能使用构造器注入sqlSessionFactory，因为它没有set方法 -->
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
</beans>
mybatis-config.xml
<?xml version="1.0" encoding="UTF8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 设置日志-->
<settings>
<!-- <setting name="logImpl" value="STDOUT_LOGGING"/>-->
<setting name="logImpl" value="LOG4J"/>
</settings>
<!-- 可以给实体类起别名-->
<typeAliases>
<!-- <typeAlias type="com.heze.pojo.User" alias="User"/>-->
<package name="com.heze.pojo"/>
</typeAliases>
</configuration>
applicationContext.xml
<?xml version="1.0" encoding="UTF8"?>
<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-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
<import resource="spring-dao.xml"/>
<bean id="userMapper" class="com.heze.mapper.UserMapperImpl">
<property name="sqlSession" ref="sqlSession"/>
</bean>
</beans>
UserMapperImpl.java
package com.heze.mapper;
import com.heze.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() {
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
return mapper.selectUser();
}
}
MyTest.java
import com.heze.mapper.UserMapper;
import com.heze.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.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class MyTest {
@Test
public void test1() throws IOException {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
List<User> userList = userMapper.selectUser();
for (User user : userList) {
System.out.println(user);
}
}
}
可使用SqlSessionDaoSupport简化获取SqlSessionTemplate
spring-dao.xml中少了创建SqlSessionTemplate这一步
<!-- SqlSessionTemplate：就是我们使用的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!-- 只能使用构造器注入sqlSessionFactory，因为它没有set方法 -->
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
applicationContext.xml中bean对象直接创建SqlSessionFactory
<bean id="userMapperTwo" class="com.heze.mapper.UserMapperImplTwo">
<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>
UserMapperImpl2.java中通过getSqlSession()来获取SqlSessionTemplate
public class UserMapperImplTwo extends SqlSessionDaoSupport implements UserMapper{
@Override
public List<User> selectUser() {
return getSqlSession().getMapper(UserMapper.class).selectUser();
}
}
13、声明式事务
13.1、回顾事务
- 要么都成功，要么都失败！
- 事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎！
- 确保完整性和一致性！
事务的ACID原则：
- 原子性
- 一致性
- 隔离性
- 多个业务可能操作同一个资源，防止数据损坏
- 持久性
- 事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化写到存储器中！
13.2、Spring中的事务管理
-
声明式事务：AOP
<!-- 配置声明式事务--> <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="add" propagation="REQUIRED"/> <tx:method name="select" propagation="REQUIRED"/> <tx:method name="delete" propagation="REQUIRED"/> <tx:method name="update" read-only="true"/> <tx:method name="*" propagation="REQUIRED"/> </tx:attributes> </tx:advice> <!-- aop:配置事务切入--> <aop:config> <aop:pointcut id="txPointCut" expression="execution(* com.heze.mapper.*.*(..))"/> <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/> </aop:config> -
编程式事务：需要在代码中，进行事物的管理
为什么需要事务？
- 如果不配置事务，可能存在数据提交不一致的情况；
- 如果我们不在Spring中去配置声明式事务，我们就需要在代码中手动配置事务；
- 事务在项目开发中十分重要，涉及到数据的一致性和完整性问题，不容马虎！
扫一扫
1072
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
