Spring
简介
- Spring：春天====》给行业带来春天
- 2002，首次推出Spring框架的雏形：interface 21框架！
- Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日，发布1.0正式版本。
- Rod Johnson，Spring Framework创始人，著名作者。很难想象Rod Johnson的学历，真的让好多人大吃一惊，他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。
- Spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！
- SSH：Struct2 + Spring + Hibernate
- SSM：SpringMVC + Spring + Mybatis
官网：https://spring.io/projects/spring-framework
4.3.9版本官方文档：https://docs.spring.io/spring-framework/docs/4.3.9.RELEASE/spring-framework-reference/
官方下载地址：https://releases.jfrog.io/ui/native/artifactory-pro/org/artifactory/pro/jfrog-artifactory-pro
github地址：https://github.com/spring-projects/spring-framework
Spring Maven：https://mvnrepository.com/artifact/org.springframework
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>6.2.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>6.2.0</version>
</dependency>
优点
- Spring是一个开源的免费的框架（容器）！
- Spring是一个轻量级的、非入侵式的框架!
- 控制反转（IOC），面相切面编程（AOP）！
- 支持事务的处理，对框架整合的支持！
总结一句话：Spring就是一个轻量级的控制反转（IOC）和面相切面编程(AOP)的框架！
组成
拓展
在Spring的官网有这个介绍：现代化的Java开发！说白就是基于Spring的开发
- Spring Boot
- 一个快速开发的脚手架
- 基于SpringBoot可以快速的开发单个微服务
- 约定大于配置！
- Spring Cloud
- SpringCloud是基于SpringBoot实现的
因为现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring及SpringMVC！承上启下的作用！
弊端：发展了太久之后，违背了原来的理念！配置十分繁琐，人称：“配置地狱”！
IOC理论推导
- UserDao 接口
- UserDaoImpl 实现类
- UserService 业务接口
- UserServiceImpl 业务实现类
spring-01-ioc1
在我们之前的业务中，用户的需求可能会影响我们的源代码，我们需要根据用户的需求去修改源代码！如果程序代码量庞大，修改成本十分昂贵！
使用Set接口实现。已经发生了革命性的改变！
//private UesrDao userDao = new UserDaoImpl();//原代码
//这样的代码，需要根据用户需求去修改源代码，思路并不正确，如果代码量庞大，修改成本巨大
private UesrDao userDao;
//利用set实现动态实现值的注入！
public void setUserDao(UesrDao userDao) {
this.userDao = userDao;
}
- 之前，程序是主动创建对象！控制权在程序猿手中！
- 使用饿了Set注入后，程序不再具有主动性，而是变成了被动接受对象！
这种思想，从本质上解决了问题，我们程序猿不用再去管理对象的创建。这是IOC的原型！
IOC本质
控制反转IOC（Inversion of Control），是一种设计思想，DI（依赖注入）是实现IOC的一种方法，也有人认为DI只是IOC的另一种说法。没有IOC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓反转就是：获得依赖对象的方式反转了。
IOC是Spring框架的核心内容，使用多种方式完美的实现了IOC，可以使用xml配置，也可以使用注解，新版本的Spring也可以零配置实现IOC。
Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从IOC容器中取出需要的对象。
才用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IOC容器，其实现方法是依赖注入（Dependency Injection，DI）。
HelloSpring
spring-02-helloSpring
需要用到的官方文档
编写一个Hello实体类
public class Hello {
private String name;
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public void show(){
System.out.println("Hello " + name);
}
@Override
public String toString(){
return "Hello{" +
"name=" + name + '}';
}
}
编写Spring文件，命名为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="org.example.pojo.Hello">
<property name="name" value="Spring"/>
</bean>
</beans>
编写测试类
public class MyTeat {
public static void main(String[] args) {
//获取Spring的上下文对象！
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//我们的对象现在都在Spring中管理了，我们要使用的话，直接从上下文获取就可以了！
Hello hello = (Hello) context.getBean("hello");//最后一个hello是beans.xml中配置的id
System.out.println(hello.toString());
hello.show();
}
}
思考问题
- Hello对象是谁创建的？
hello对象是由spring创建的
- Hello对象的属性是怎么设置的？
hello对象的属性是由Spring容器设置的
这个过程就叫过程反转：
控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的
反转：程序本身不创建对象，而变成被动的接收对象
依赖注入：就是利用Set方法来进行注入的
IOC是一种编程思想，由主动的编程变成被动的接收
可以通过new ClassPathXmlApplicationContext去浏览一下底层源码
OK，到了现在，我们彻底不用在程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓的IOC，一句话搞定：对象由Spring来创建，管理，装配！
spring-01-ioc2
复制spring-01-ioc1的内容，编写Spring类，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="mysqlImpl" class="org.example.dao.UserDaoMysqlImpl"></bean>
<bean id="oracleImpl" class="org.example.dao.UserDaoOracleImpl"></bean>
<bean id="userServiceImpl" class="org.example.service.UserServiceImpl">
<property name="userDao" ref="mysqlImpl"/>
<!--ref的值改成oracleImpl，测试类获取的值就是oracle-->
</bean>
<!--
ref: 引用spring容器中已经创建好的对象
value: 具体的值，基本数据类型
-->
</beans>
编写测试类
public static void main(String[] args) {
//获取ApplicationContext; 拿到Spring的容器
ApplicationContext Context = new ClassPathXmlApplicationContext("beans.xml");
//容器在手，天下我有，需要什么，就直接get什么！
UserServiceImpl userServiceImpl = (UserServiceImpl) Context.getBean("userServiceImpl");
userServiceImpl.getUser();//MYSQL获取用户数据
}
IOC创建对象方式
1.使用无参构造创建对象（默认）
2.假设我们要使用有参构造创建对象
1.下标赋值
<!--第一种，下标赋值-->
<bean id="user" class="org.example.pojo.User">
<constructor-arg index="0" value="louis"/>
</bean>
2.类型
<!--第二种，通过类型创建，不建议使用，类型相同时无法使用-->
<bean id="user" class="org.example.pojo.User">
<constructor-arg type="java.lang.String" value="louis"/>
</bean>
3.参数名
<!--第三种，直接通过参数名来设置-->
<bean id="user" class="org.example.pojo.User">
<constructor-arg name="name" value="louis"/>
</bean>
总结：在配置文件加载的时候，容器（bean）中管理的对象就已经初始化了！
Spring配置
1.别名
<!--别名，如果添加了别名，我们也可以使用别名获取到这个对象-->
<alias name="user" alias="userNew"/>
2.Bean的配置
<!--
id : bean的唯一标识符,也就是相当于对象名
class : bean对象所对应的全限定名 : 包名+类型
name : 也是别名，而且name更高级 可以同时取多个别名 别名之间可以用空格、逗号、分号进行分搁
-->
<bean id="UserT" class="org.example.pojo.UserT" name="user2,u2">
<property name="name" value="123456"/>
</bean>
3.import
import,一般用于团队开发使用，他可以将多个配置文件，导入合并为一个
假设现在项目中有多个人开发，这三个人负责不同的类开发，不同的类需要注册在不同的Bean中，我们可以利用import将所有人的bean.xml合并为一个总的！
- 张三
- 李四
- 王五
- applicationContext.xml
使用的时候，直接使用总的配置就可以了
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<import resource="beans.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>
</beans>
DI依赖注入
构造器注入
// 构造器注入
public Notification(MessageService messageService) {
this.messageService = messageService;
}
Set方式注入【重点】
- 依赖注入:Set注入！
- 依赖：bean对象的创造依赖于容器！
- 注入：bean对象中的所有属性，由容器来注入！
【环境搭建】
1.复杂类型
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
2.真实测试对象
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 Married;
private Properties info;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public String[] getBooks() {
return books;
}
public void setBooks(String[] books) {
this.books = books;
}
public List<String> getHobbys() {
return hobbys;
}
public void setHobbys(List<String> hobbys) {
this.hobbys = hobbys;
}
public Map<String, String> getCard() {
return card;
}
public void setCard(Map<String, String> card) {
this.card = card;
}
public Set<String> getGames() {
return games;
}
public void setGames(Set<String> games) {
this.games = games;
}
public String getMarried() {
return Married;
}
public void setMarried(String married) {
Married = married;
}
public Properties getInfo() {
return info;
}
public void setInfo(Properties info) {
this.info = info;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", address=" + address +
", books=" + Arrays.toString(books) +
", hobbys=" + hobbys +
", card=" + card +
", games=" + games +
", Married='" + Married + '\'' +
", info=" + info +
'}';
}
}
3.applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="student" class="com.liu.pojo.Student">
<!--第一种：普通值注入，value-->
<property name="name" value="louis"/>
</bean>
</beans>
4.测试类
import com.liu.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("applicationContext.xml");
Student student = (Student) context.getBean("student");
System.out.println(student.getName());
}
}
完善注入信息
<?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.liu.pojo.Address">
<property name="address" value="福建"/>
</bean>
<bean id="student" class="com.liu.pojo.Student">
<!--第一种：普通值注入，value-->
<property name="name" value="louis"/>
<!--第二种：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>
</list>
</property>
<!--Map-->
<property name="card">
<map>
<entry key="身份证" value="12316541564165165"/>
<entry key="银行卡" value="15646 15616 1516 545"/>
</map>
</property>
<!--Set-->
<property name="games">
<set>
<value>LOL</value>
<value>原神</value>
<value>永劫无间</value>
</set>
</property>
<!--null //无填入任何尖括号内容返回为空值-->
<property name="married">
<null/>
</property>
<!--Properties-->
<property name="info">
<props>
<prop key="学号">221550053</prop>
<prop key="性别">男</prop>
<prop key="姓名">louis</prop>
</props>
</property>
</bean>
</beans>
拓展方式注入
我们可以使用p命名空间和c命名空间进行注入
使用
<?xml version="1.0" encoding="UTF-8"?>
<!--增加p命名空间-->
<!--增加c命名空间-->
<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命名空间注入，可以直接注入属性的值：property-->
<bean id="user" class="com.liu.pojo.User" p:name="louis" p:age="18"/>
<!--c命名空间注入，通过构造器注入：construct-args-->
<bean id="user2" class="com.liu.pojo.User" c:age="18" c:name="LIU"/>
</beans>
测试
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
User user = context.getBean("user", User.class);//显式声明类型后不需要强转
System.out.println(user);
/*
User{
name='louis'
age=18
}
*/
}
@Test
public void test3(){
ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
User user = context.getBean("user2", User.class);//显式声明类型后不需要强转
System.out.println(user);
/*
User{
name='LIU'
age=18
}
*/
}
注意点：p命名和c命名空间不能直接使用，需要导入xml约束！
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
Bean的作用域
- 单例模式（Spring默认机制）
<bean id="accountService" class="com.foo.DefaultAccountService" scope="singleton"/>
- 原型模式：每次从容器中get的时候，都会产生一个新对象！
<bean id="accountService" class="com.foo.DefaultAccountService" scope="prototype"/>
- 其余的 request、session、application、这些只能在web开发中使用到！
Bean的自动装配
- 自动装配是Spring是满足Bean依赖的一种方式！
- Spring会在上下文自动寻找，并自动给Bean装配属性！
在Spring中有三种装配的方式
- 在xml中显式的配置
- 在Java中显式装配
- 隐式的自动装配bean【重要】
测试
- 环境搭建
- 一个人有两只宠物！
ByName自动装配
<bean id="cat" class="com.liu.pojo.Cat"/>
<bean id="dog" class="com.liu.pojo.Dog"/>
<!--
byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid
-->
<bean id="people" class="com.liu.pojo.People" autowire="byName">
<property name="name" value="louis"/>
</bean>
ByType自动装配
<bean class="com.liu.pojo.Cat"/>
<bean class="com.liu.pojo.Dog"/>
<!--
byType：会自动在容器上下文中查找，和自己对象对象类型相同的bean，id可省略
-->
<bean id="people" class="com.liu.pojo.People" autowire="byName">
<property name="name" value="louis"/>
</bean>
小结：
- byname的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致！
- bytype的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致！
使用注解实现自动装配
jdk1.5开始支持注解，spring2.5开始支持
The introduction of annotation-based configurations raised the question of whether this approach is ‘better’ than XML.
要使用注解须知：
- 导入约束 context约束
- 配置注解的支持 context:annotation-config/ 【重要！！！】
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
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注解(Spring)
直接在属性上使用即可！也可以在set方式上使用！
使用Autowired我们可以不用编写Set方法了，前提是你这个自动装配的属性在IOC（spring）容器中存在，且符合名字byname！
科普：
@Nullable 字段标记了这个注解，说明这个字段可以为null
public void setName(@Nullable String name) {
this.name = name;
}
public @interface Autowired {
boolean required() default true;
}
测试代码：
public class SimpleMovieLister {
private MovieFinder movieFinder;
//如果显示定义了Autowired的required的属性为false，说明这个对象可以为null，否则不允许为空！
@Autowired(required=false)
public void setMovieFinder(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}
// ...
}
如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解@Autowired完成的时候，我们可以使用@Qualifier(value=“xxx”)去配合@Autowired的使用，指定一个唯一的bean对象注入！
public class People {
@Autowired
@Qualifier(value = "cat")
private Cat cat;
@Autowired
@Qualifier(value = "dog")
private Dog dog;
private String name;
}
<bean id="cat" class="com.liu.pojo.Cat"/>
<bean id="cat1" class="com.liu.pojo.Cat"/>
<bean id="cat11" class="com.liu.pojo.Cat"/>
<bean id="dog" class="com.liu.pojo.Dog"/>
<bean id="dog22" class="com.liu.pojo.Dog"/>
<bean id="dog222" class="com.liu.pojo.Dog"/>
<bean id="people" class="com.liu.pojo.People"/>
@Resource注解(java)
public class People {
@Resource(name = "cat")
private Cat cat;
@Resource
private Dog dog;
private String name;
}
小结
@Resource和@Autowired的异同点：
- 同：都是用来自动装配的，都可以放在属性字段上
- @Autowired通过byname的方式实现，而且必须要求这个对象存在！【常用】
- @Resource默认通过byname的方式实现，如果找不到名字，则通过bytype实现！如果两个都找不到的情况下，就报错！【常用】
- 执行顺序不同：@Autowired通过bytype的方式实现。@Resource默认通过byname的方式实现。
使用注解开发
在Spring4之后，要使用注解开发，必须要保证aop的包导入了
使用注解需要导入context约束，增加注解的支持
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<context:annotation-config/>
</beans>
bean
属性如何注入
package com.liu.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
//等价于<bean id="user" class="com.liu.pojo.User"/>
//@Component 组件,放在类上，说明这个类被Spring管理了，就是bean！
@Component
public class User {
//相当于<property name="name" value="louis"/>
@Value("louis")
public String name;
//相当于<property name="name" value="louis"/>
@Value("louis")
public void setName(String name) {
this.name = name;
}
}
衍生的注解
@Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层！
- dao 【@Repository】
- service 【@Service】
- controller 【@Controller】
这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean
自动装配
- @Autowired自动装配的环境比较复杂，自动装配无法通过一个注解@Autowired完成的时候，我们可以使用@Qualifier(value=“xxx”)去配合@Autowired的使用，指定一个唯一的bean对象注入！
- @Resource默认通过byname的方式实现，如果找不到名字，则通过bytype实现！如果两个都找不到的情况下，就报错！
- @Nullable 字段标记了这个注解，说明这个字段可以为null
作用域
@Component
@Scope("singleton")
public class User {
//相当于<property name="name" value="louis"/>
@Value("louis")
public String name;
//相当于<property name="name" value="louis"/>
@Value("louis")
public void setName(String name) {
this.name = name;
}
}
小结
xml与注解：
- xml更加万能，适用于任何场合！维护简单方便
- 注解不是自己类使用不了，维护相对复杂！
xml与注解最佳实践：
- xml用来管理bean
- 注解只负责完成属性的注入
- 我们在使用的过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持
<context:annotation-config/>
<!--指定要扫描的包，这个包下的注解就会生效-->
<context:component-scan base-package="com.liu"/>
使用Java的方式配置Spring
我们现在要完全不使用Spring的xml配置了，全权交给Java来做！
JavaConfig是Spring的一个子项目，在Spring4之后，它成为了一个核心功能
Ctrl+Alt+B快捷查看实现类
实体类
package com.liu.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
//这里这个注解的意思，就是说明这个类被Spring接管了，注册到了容器中
@Component
public class User {
public String name;
public String getName() {
return name;
}
@Value("Louis") //属性注入值
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
配置文件
package com.liu.config;
import com.liu.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;
//这个也会被Spring容器托管，注册到容器中，因为他本来就是一个@Component
//@Configuration代表这是一个配置类，就和我们之前看的Beans.xml是一样的
@Configuration
//扫描
@ComponentScan("com.liu.pojo")
//引入配置类
@Import(LiuConfig2.class)
public class LiuConfig {
//注册一个bean，就相当于我们之前写的一个bean标签
//这个方法的名字，就相当于bean标签中的id属性
//这个方法的返回值，就相当于bean标签中的class属性
@Bean
public User getUser(){
return new User(); //就是返回要注入到bean的对象！
}
}
package com.liu.config;
import org.springframework.context.annotation.Configuration;
@Configuration
public class LiuConfig2 {
}
测试类
import com.liu.config.LiuConfig;
import com.liu.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(LiuConfig.class);
User getUser = context.getBean("getUser", User.class);
System.out.println(getUser.getName());
}
}
这种纯Java的配置方式，在SpringBoot中随处可见！
代理模式
为什么要学习代理模式？因为这既是SpringAOP的底层！【SpringAOP和SpringMVC】
代理模式的分类：
- 静态代理
- 动态代理
静态代理
角色分析：
- 抽象角色：一般会使用接口或者抽象类来解决
- 真实角色：被代理的角色
- 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
- 客户：访问代理对象的人
代码步骤：
-
接口
package com.liu.demo01; //租房 public interface Rent { public void rent(); } -
真实角色
package com.liu.demo01; //房东 public class Host implements Rent{ @Override public void rent() { System.out.println("房东要出租房子"); } } -
代理角色
package com.liu.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("收中介费"); } } -
客户端访问代理角色
package com.liu.demo01; public class Client { public static void main(String[] args) { //房东要租房子 Host host = new Host(); //代理，中介帮房东出租房子，但是呢？代理角色一般会有一些附属操作 Proxy proxy = new Proxy(host); //你不用面对房东，直接找中介租房即可！ proxy.rent(); } }
代理模式的好处;
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共也就交给代理角色！实现了业务的分工！
- 公共业务发生拓展的时候，方便集中管理!
缺点：
- 一个真实角色就会产生一个代理角色；代码量会翻倍~开发效率会变低
加深理解
聊聊AOP
-
接口
package com.liu.demo02; public interface UserService { public void add(); public void delete(); public void update(); public void query(); } -
真实角色
package com.liu.demo02; //真实对象 public class UserServiceImpl implements UserService{ public void add(){ System.out.println("增加了一个用户"); } public void delete(){ System.out.println("删除了一个用户"); } public void update(){ System.out.println("修改了一个用户"); } public void query(){ System.out.println("查询了一个用户"); } //1、改动原有的业务代码，在公司中是大忌！ } -
代理
package com.liu.demo02; public class UserServiceProxy implements UserService{ private UserServiceImpl userService; public void setUserService(UserServiceImpl userService) { this.userService = userService; } public void add(){ log("add"); userService.add(); } public void delete(){ log("delete"); userService.delete(); } public void update(){ log("update"); userService.update(); } public void query(){ log("query"); userService.query(); } //日志方法 public void log(String msg){ System.out.println("[Debug] 使用了"+msg+"方法"); } } -
调用方法
package com.liu.demo02; public class Client { public static void main(String[] args) { UserServiceImpl userService = new UserServiceImpl(); UserServiceProxy proxy = new UserServiceProxy(); proxy.setUserService(userService); proxy.add(); proxy.delete(); proxy.update(); proxy.query(); } }
动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的，不是我们直接写好的！
- 动态代理也分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口——JDK动态代理【我们在这里使用】
- 基于类——cglib
- java字节码实现：javassist
需要了解两个类：Proxy：代理，InvocationHandler：调用处理程序
-
接口
package com.liu.demo03; //租房 public interface Rent { public void rent(); } -
真实角色
package com.liu.demo03; //房东 public class Host implements Rent { @Override public void rent() { System.out.println("房东要出租房子"); } } -
代理
package com.liu.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); } //处理代理实例并返回结果 @Override 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.liu.demo03; public class Client { public static void main(String[] args) { //真实角色 Host host = new Host(); //代理角色： 现在没有 ProxyInvocationHandler pih = new ProxyInvocationHandler(); //通过调用程序处理角色来处理我们要调用的接口对象！ pih.setRent(host); Rent proxy = (Rent) pih.getProxy();//这里的proxy就是动态生成的，我们并没有写！ proxy.rent(); } }
万能类（模板）
代理
package com.liu.demo04;
import com.liu.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 {
//动态代理的本质，就是使用反射机制实现
log(method.getName());
Object result = method.invoke(target, args);
return result;
}
public void log(String msg){
System.out.println("执行了"+msg+"方法");
}
}
客户
package com.liu.demo04;
import com.liu.demo02.UserService;
import com.liu.demo02.UserServiceImpl;
public class Client {
public static void main(String[] args) {
//真实角色
UserServiceImpl userService = new UserServiceImpl();
//代理角色，不存在
ProxyInvocationHandler pih = new ProxyInvocationHandler();
pih.setTarget(userService);//设置要代理的对象
//动态生成代理类
UserService proxy = (UserService) pih.getProxy();
proxy.delete();
}
}
动态代理的好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共也就交给代理角色！实现了业务的分工！
- 公共业务发生拓展的时候，方便集中管理!
- 一个动态代理类代理的是一个接口，一般就是对应的一类业务
- 一个动态代理类可以代理多个类，只要是实现了同一个接口即可
AOP
什么是AOP？
AOP（Aspect Oriented Programming）即面向切面编程，是一种通过预编译方式和运行期动态代理实现程序功能的统一维护的技术。AOP是OOP（面向对象编程）的延续和补充，旨在解决传统OOP中代码重复、耦合度高和难以维护等问题。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发效率。
Aop在Spring中的作用
提供生命式业务；允许用户自定义切面
- 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部
分，就是横切关注点。如日志,安全，缓存,事务等等…… - 切面(ASPECT)：横切关注点被模块化的特殊对象。即，它是一个类。 【DiyPointCut】
- 通知（Advice)：切面必须要完成的工作。即，它是类中的一个方法。 【DiyPointCut中的方法】
- 目标(Target)：被通知对象.
- 代理(Proxy)：向目标对象应用通知之后创建的对象。
- 切入点(PointCut)：切面通知执行的“地点的定义。
- 连接点JointPoint)：与切入点匹配的执行点。
SpringAop中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice：
即AOP在不改变原有代码的情况下，去增加新的功能。
使用Spring实现Aop
【重点】使用AOP织入，需要导入一个依赖包！
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
<scope>runtime</scope>
</dependency>
方式一：使用Spring的API接口【主要SpringAPI接口实现】
-
接口
package com.liu.service; public interface UserService { public void add(); public void delete(); public void update(); public void select(); } -
真实角色
package com.liu.service; public class UserServiceImpl implements UserService{ @Override public void add() { System.out.println("增加了一个用户"); } @Override public void delete() { System.out.println("删除了一个用户"); } @Override public void update() { System.out.println("更新了一个用户"); } @Override public void select() { System.out.println("查询了一个用户"); } } -
aop方法
package com.liu.log; import org.springframework.aop.MethodBeforeAdvice; import java.lang.reflect.Method; public class Log implements MethodBeforeAdvice { //method：要执行的目标对象的方法 //args：参数 //target：目标对象 @Override public void before(Method method, Object[] args, Object target) throws Throwable { System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了"); } }package com.liu.log; import org.springframework.aop.AfterReturningAdvice; import java.lang.reflect.Method; public class AfterLog implements AfterReturningAdvice { //returnValue：返回值 @Override public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable { System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue); } } -
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"> <!--注册bean--> <bean id="userService" class="com.liu.service.UserServiceImpl"/> <bean id="log" class="com.liu.log.Log"/> <bean id="afterlog" class="com.liu.log.AfterLog"/> <!--方式一：使用原生Spring API接口--> <!--配置aop：需要导入aop的约束--> <aop:config> <!--切入点：experssion:表达式，execution(要执行的位置！* * * * *)--> <aop:pointcut id="pointcut" expression="execution(* com.liu.service.UserServiceImpl.*(..))"/> <!--执行环绕增加--> <aop:advisor advice-ref="log" pointcut-ref="pointcut"/> <aop:advisor advice-ref="afterlog" pointcut-ref="pointcut"/> </aop:config> </beans> -
测试类
import com.liu.service.UserService; import com.sun.org.apache.xpath.internal.CachedXPathAPI; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class MyTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); //动态代理代理的是接口：注意点 UserService userService = context.getBean("userService", UserService.class); userService.add(); } }
方式二：自定义类来实现AOP 【主要是切面定义】
-
接口
package com.liu.service; public interface UserService { public void add(); public void delete(); public void update(); public void select(); } -
真实角色
package com.liu.service; public class UserServiceImpl implements UserService{ @Override public void add() { System.out.println("增加了一个用户"); } @Override public void delete() { System.out.println("删除了一个用户"); } @Override public void update() { System.out.println("更新了一个用户"); } @Override public void select() { System.out.println("查询了一个用户"); } } -
自定义类
package com.liu.diy; public class DiyPointCut { public void before(){ System.out.println("============方法执行前============="); } public void after(){ System.out.println("============方法执行后============="); } } -
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"> <!--注册bean--> <bean id="userService" class="com.liu.service.UserServiceImpl"/> <bean id="diy" class="com.liu.diy.DiyPointCut"/> <!--方法二：自定义类--> <aop:config> <!--自定义切面，ref要引用的类--> <aop:aspect ref="diy"> <!--切入点--> <aop:pointcut id="point" expression="execution(* com.liu.service.UserServiceImpl.*(..))"/> <!--通知--> <aop:before method="before" pointcut-ref="point"/> <aop:after method="after" pointcut-ref="point"/> </aop:aspect> </aop:config> </beans> -
测试类
import com.liu.service.UserService; import com.sun.org.apache.xpath.internal.CachedXPathAPI; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class MyTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); //动态代理代理的是接口：注意点 UserService userService = context.getBean("userService", UserService.class); userService.add(); } }
方式三：使用注解实现！
-
接口
package com.liu.service; public interface UserService { public void add(); public void delete(); public void update(); public void select(); } -
真实角色
package com.liu.service; public class UserServiceImpl implements UserService{ @Override public void add() { System.out.println("增加了一个用户"); } @Override public void delete() { System.out.println("删除了一个用户"); } @Override public void update() { System.out.println("更新了一个用户"); } @Override public void select() { System.out.println("查询了一个用户"); } } -
注解实现类
package com.liu.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.liu.service.UserServiceImpl.*(..))") public void before(){ System.out.println("============方法执行前============="); } @After("execution(* com.liu.service.UserServiceImpl.*(..))") public void after(){ System.out.println("============方法执行后============="); } //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点 @Around("execution(* com.liu.service.UserServiceImpl.*(..))") public void around(ProceedingJoinPoint jp) throws Throwable{ System.out.println("环绕前"); //执行方法 Object proceed = jp.proceed(); System.out.println("环绕后"); // Signature signature = jp.getSignature();//获得签名 // System.out.println(signature); } } -
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"> <!--注册bean--> <bean id="userService" class="com.liu.service.UserServiceImpl"/> <bean id="annotationPointCut" class="com.liu.diy.AnnotationPointCut"/> <!--方式三：使用注解方式实现AOP--> <!--开启注解支持 JDK(默认 proxy-target-class="false") cglib（proxy-target-class="true"）--> <aop:aspectj-autoproxy/> </beans> -
测试类
import com.liu.service.UserService; import com.sun.org.apache.xpath.internal.CachedXPathAPI; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class MyTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); //动态代理代理的是接口：注意点 UserService userService = context.getBean("userService", UserService.class); userService.add(); } }
整合Mybatis
步骤：
-
导入相关jar包
- junit
- mybatis
- MySQL数据库
- Spring相关的
- aop织入
- mybatis-Spring【new】https://mybatis.org/spring/zh_CN/index.html
-
编写配置文件(pom)
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.example</groupId> <artifactId>Spring-study</artifactId> <version>1.0-SNAPSHOT</version> </parent> <artifactId>spring-10-mybatis</artifactId> <dependencies> <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.3.25</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.28</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.9</version> <!-- 确保使用最新的稳定版本 --> </dependency> <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver --> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.4</version> <scope>runtime</scope> </dependency> <!--Spring操作数据库的话，还需要一个spring-jdbc--> <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>7.0.0-M2</version> </dependency> <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>3.0.4</version> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.24</version> </dependency> <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>6.2.3</version> </dependency> </dependencies> <build> <resources> <resource> <directory>src/main/java</directory> <includes> <include>**/*.xml</include> </includes> <filtering>true</filtering> </resource> <resource> <directory>src/main/resources</directory> </resource> </resources> </build> <name>Archetype - spring-10-mybatis</name> <url>http://maven.apache.org</url> </project> -
测试(连接mybatis)
回忆mybatis
-
编写实体类
package com.liu.pojo; import lombok.Data; @Data public class User { private int id; private String name; private String pwd; } -
编写核心配置文件
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "https://mybatis.org/dtd/mybatis-3-config.dtd"> <!--configuration核心配置文件--> <configuration> <typeAliases> <package name="com.liu.pojo"/> </typeAliases> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <property name="driver" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8"/> <property name="username" value="root"/> <property name="password" value="root"/> </dataSource> </environment> </environments> <mappers> <mapper class="com.liu.mapper.UserMapper"/> </mappers> </configuration> -
编写接口
package com.liu.mapper; import com.liu.pojo.User; import java.util.List; public interface UserMapper { public List<User> selectUser(); } -
编写Mapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "https://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!--configuration核心配置文件--> <mapper namespace="com.liu.mapper.UserMapper"> <select id="selectUser" resultType="user"> select * from mybatis.user; </select> </mapper> -
测试
import com.liu.mapper.UserMapper; import com.liu.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 test() throws IOException { String resources = "mybatis-config.xml"; InputStream in = Resources.getResourceAsStream(resources); SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in); SqlSession sqlSession = sessionFactory.openSession(true); UserMapper mapper = sqlSession.getMapper(UserMapper.class); List<User> userList = mapper.selectUser(); for (User user : userList) { System.out.println(user); } } }
Mybatis-spring（方式一）
-
编写数据源配置
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.example</groupId> <artifactId>Spring-study</artifactId> <version>1.0-SNAPSHOT</version> </parent> <artifactId>spring-10-mybatis</artifactId> <dependencies> <!-- Spring Web MVC --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.3.25</version> </dependency> <!-- JUnit for testing --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency> <!-- MySQL Connector --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.28</version> </dependency> <!-- MyBatis --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.9</version> </dependency> <!-- AspectJ Weaver --> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.4</version> <scope>runtime</scope> </dependency> <!-- Spring JDBC --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.3.25</version> <!-- 确保与Java 8兼容 --> </dependency> <!-- Spring TX --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-tx</artifactId> <version>5.3.25</version> <!-- 确保与Java 8兼容 --> </dependency> <!-- MyBatis-Spring --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.6</version> </dependency> <!-- Lombok --> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.24</version> </dependency> </dependencies> <build> <resources> <resource> <directory>src/main/java</directory> <includes> <include>**/*.xml</include> </includes> <filtering>true</filtering> </resource> <resource> <directory>src/main/resources</directory> </resource> </resources> </build> <name>Archetype - spring-10-mybatis</name> <url>http://maven.apache.org</url> </project> -
sqlSessionFactory
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"> <!--DataSource:使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid 我们这里使用Spring提供的JDBC --> <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&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/liu/mapper/*.xml"/> </bean> <!--SqlSessionTemplate:就是我们使用的sqlSession--> <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"> <!--只能使用构造器注入sqlSessionFactory，因为它没有set方法--> <constructor-arg index="0" ref="sqlSessionFactory"/> </bean> </beans> -
sqlSessionTemplate
package com.liu.mapper; import com.liu.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; } public List<User> selectUser() { UserMapper mapper = sqlSession.getMapper(UserMapper.class); return mapper.selectUser(); } } -
mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "https://mybatis.org/dtd/mybatis-3-config.dtd"> <!--configuration核心配置文件--> <configuration> <!--别名--> <typeAliases> <package name="com.liu.pojo"/> </typeAliases> <!--设置--> <!-- <settings>--> <!-- <!–开启驼峰命名法–>--> <!-- <setting name="" value=""/>--> <!-- </settings>--> </configuration> -
需要给接口加实现类
-
接口
package com.liu.mapper; import com.liu.pojo.User; import java.util.List; public interface UserMapper { public List<User> selectUser(); } -
UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "https://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!--configuration核心配置文件--> <mapper namespace="com.liu.mapper.UserMapper"> <select id="selectUser" resultType="user"> select * from mybatis.user; </select> </mapper> -
接口的实现类
package com.liu.mapper; import com.liu.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; } public List<User> selectUser() { UserMapper mapper = sqlSession.getMapper(UserMapper.class); return mapper.selectUser(); } }
-
-
将自己写的实现类，注入到Spring中
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"> <!--DataSource:使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid 我们这里使用Spring提供的JDBC --> <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&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/liu/mapper/*.xml"/> </bean> <!--绑定Mybatis配置文件--> <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"> <!--只能使用构造器注入sqlSessionFactory，因为它没有set方法--> <constructor-arg index="0" ref="sqlSessionFactory"/> </bean> <!--将自己写的实现类，注入到Spring中--> <bean id="userMapper" class="com.liu.mapper.UserMapperImpl"> <property name="sqlSession" ref="sqlSession"/> </bean> </beans> -
测试使用即可！
import com.liu.mapper.UserMapper; import com.liu.pojo.User; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import java.io.IOException; public class MyTest { @Test public void test() throws IOException { ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml"); UserMapper userMapper = context.getBean("userMapper", UserMapper.class); for (User user : userMapper.selectUser()) { System.out.println(user); } } }
Mybatis-spring（方式二）
-
UserMapperImpl2.java
package com.liu.mapper; import com.liu.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(); return sqlSession.getMapper(UserMapper.class).selectUser(); } } -
spring-dao.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"> <!--DataSource:使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid 我们这里使用Spring提供的JDBC --> <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&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/liu/mapper/*.xml"/> </bean> <!--SqlSessionTemplate:就是我们使用的sqlSession--> <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"> <!--只能使用构造器注入sqlSessionFactory，因为它没有set方法--> <constructor-arg index="0" ref="sqlSessionFactory"/> </bean> </beans> -
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <import resource="spring-dao.xml"/> <bean id="userMapper2" class="com.liu.mapper.UserMapperImpl2"> <property name="sqlSessionFactory" ref="sqlSessionFactory"/> </bean> </beans> -
MyTest.java
import com.liu.mapper.UserMapper; import com.liu.pojo.User; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import java.io.IOException; public class MyTest { @Test public void test() throws IOException { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); UserMapper userMapper = context.getBean("userMapper2", UserMapper.class); for (User user : userMapper.selectUser()) { System.out.println(user); } } }
声明式事务
回顾事务
- 把一组事务当成一个事务来做，要么都成功，要么都失败！
- 事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎！
- 确保完整性和一致性；
事务ACID原则：
- 原子性
- 一致性
- 隔离性
- 多个业务可能操作同一个资源，防止数据损坏
- 持久性
- 事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化的写到存储器中！
Spring中的事务管理
- 声明式事务：AOP
- 编程式事务：需要在代码中，进行事务的管理
思考：
为什么需要事务？
- 如果不配置事务，可能存在数据提交不一致的情况下；
- 如果我们不在Spring中去配置声明式事务，我们就需要在代码中手动配置事务
- 事务在项目的开发中十分重要，涉及到数据的一致性和完整性问题，不容马虎！
pojo
user
package com.liu.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private int id;
private String name;
private String pwd;
}
mapper
UserMapperImpl
package com.liu.mapper;
import com.liu.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.List;
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
@Override
public List<User> selectUser() {
User user = new User(5, "小王", "password123");
UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
mapper.addUser(user);
mapper.deleteUser(5);
return mapper.selectUser();
}
@Override
public int addUser(User user) {
return getSqlSession().getMapper(UserMapper.class).addUser(user);
}
@Override
public int deleteUser(int id) {
return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
}
}
UserMapper
package com.liu.mapper;
import com.liu.pojo.User;
import java.util.List;
public interface UserMapper {
List<User> selectUser();
//添加一个用户
public int addUser(User user);
//删除一个用户
public int deleteUser(int id);
}
UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--configuration核心配置文件-->
<mapper namespace="com.liu.mapper.UserMapper">
<select id="selectUser" resultType="user">
select * from mybatis.user;
</select>
<insert id="addUser" parameterType="user">
insert into mybatis.user(id,name,pwd) values (#{id},#{name},#{pwd});
</insert>
<delete id="deleteUser" parameterType="int">
delete from mybatis.user where id = #{id};
</delete>
</mapper>
resources
spring-dao.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<!--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"/>
<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/liu/mapper/*.xml"/>
</bean>
<!--SqlSessionTemplate:就是我们使用的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--只能使用构造器注入sqlSessionFactory，因为它没有set方法-->
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
<!--配置声明式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--两种注入方式均可-->
<!--<property name="dataSource" ref="datasource"/>-->
<constructor-arg ref="datasource"/>
</bean>
<!--结合AOP实现事务的织入-->
<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!--给哪些方法配置事务-->
<!--配置事务的传播特性：new propagation，默认REQUIRED-->
<tx:attributes>
<!--<tx:method name="add" propagation="REQUIRED"/>-->
<!--<tx:method name="delete" propagation="REQUIRED"/>-->
<!--<tx:method name="update" propagation="REQUIRED"/>-->
<!--<tx:method name="query" read-only="true"/>-->
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!--配置事务切入-->
<aop:config>
<aop:pointcut id="txPointCut" expression="execution(* com.liu.mapper.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>
</beans>
mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"https://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration核心配置文件-->
<configuration>
<!--别名-->
<typeAliases>
<package name="com.liu.pojo"/>
</typeAliases>
</configuration>
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<import resource="spring-dao.xml"/>
<!--bean-->
<bean id="userMapper" class="com.liu.mapper.UserMapperImpl">
<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>
</beans>
测试
MyTest
import com.liu.mapper.UserMapper;
import com.liu.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
List<User> users = userMapper.selectUser();
for (User user : users) {
System.out.println(user);
}
}
}
扫一扫
2422
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
