官网:[https://docs.spring.io/spring-framework/docs/current/reference/html/]
下载地址:[https://github.com/spring-projects/spring-framework/releases]
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.3.9</version> </dependency> <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.3.9</version> </dependency>
总结:Spring就是一个轻量级的控制反转(IOC)和面向切面编程(AOP)的框架。
在Spring的官网有这个介绍:现代化的Java开发,说白了就是基于Spring的开发。
现在大多数公司都在使用SpringBoot进行快速开发,学习SpringBoot的前提,需要完全掌握Spring及SpringMVC。
创建dao层接口和实现类
public interface UserDao { void getUser(); }
public class UserDaoImpl implements UserDao { @Override public void getUser() { System.out.println("获取用户的数据"); } }
创建Service层
public interface UserService { void getUser(); }
public class UserServiceImpl implements UserService { UserDao userDao = new UserDaoImpl(); @Override public void getUser() { userDao.getUser(); } }
测试
public class UserTest { public static void main(String[] args) { //用户调的是业务层,dao层他们不需要接触 UserServiceImpl userService = new UserServiceImpl(); userService.getUser(); } }
分析:
所以如何解决这个问题变得尤为重要:
变更目的:程序不变,变的是客户端。
public class UserServiceImpl implements UserService { //每次增加需求,都需要改变new 的对象 UserDao userDao = new UserDaoImpl(); @Override public void getUser() { userDao.getUser(); } }
只使用一个Set接口实现,已经发生了革命性的变化!
上面的UserService实现类改变为:
public class UserServiceImpl implements UserService { // UserDao userDao = new UserDaoImpl(); private UserDao userDao; //变更之后,实现类无需更改,用户只需要在测试类中调用即可 public void setUserDao(UserDao userDao) { this.userDao = userDao; } @Override public void getUser() { userDao.getUser(); } }
测试类:
public static void main(String[] args) { UserServiceImpl userService = new UserServiceImpl(); //userService.setUserDao(new UserDaoTest1Impl()); userService.setUserDao(new UserDaoTest2Impl()); userService.getUser(); }
这种思想,从本质上解决了问题,我们程序员不用再去管理对象的创建了,系统的耦合性大大降低,可以更加专注的在业务的实现上。这是IOC的原型!
早期的主动权在程序员,程序调用什么
后来的主动权在用户,用户去选择调用什么,移交了自己的主动权。
控制反转是一种设计思想,DI是实现IoC的一种方式。
控制反转IoC(Inversion of Control),是一种设计思想,DI(依赖注入)是实现IoC的一种方式。
没有Ioc的程序中,我们使用面向对象编程,对象的创建与对象间的依赖关系完全硬编码在程序中,对象的创建由程序自己控制,控制反转后将程序的创建转移给第三方,个人认为所谓的控制反转就是:获得依赖对象的方式转变了。
控制反转是一种通过描述(XML或注解)并通过第三方生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器,其实现方法是依赖注入(Dependency injection,DI)。
创建Hello实体类
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 + '\'' + '}'; } }
编写spring文件,在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"> <!-- 使用spring创建对象,在Spring中这些都成为Bean 类型 变量名 = new 类型(); Hello hello = new Hello(); id = 变量名 class = 类型 property 相当于给对象中的属性设置一个值。 --> <bean id="hello" class="com.ls.pojo.Hello"> <property name="str" value="Spring"/> </bean> </beans>
测试
public class HelloTest { public static void main(String[] args) { //获取Spring的上下文对象 ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); //我们的对象现在都在Spring中的管理了,需要使用,直接从里面取出来即可 Hello hello = (Hello) context.getBean("hello"); System.out.println(hello.toString()); } }
输出
思考:
Hello是谁创建的?
【hello对象是由Spring创建的】
Hello对象的属性怎么设置的?
【是由Spring容器设置的】
这个过程就叫控制反转:
依赖注入:就是利用set()方法来进行注入的。
IOC是一种编程思想,由主动的编程变成被动的接收。可以通过newClassPathXmlApplicationContext去浏览一下底层源码 。
修改第一个项目(spring-01-ioc1)
新增一个Spring配置文件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"> <!-- 使用spring创建对象,在Spring中这些都成为Bean 类型 变量名 = new 类型(); Hello hello = new Hello(); id = 变量名 class = 类型 property 相当于给对象中的属性设置一个值。 --> <bean id="userDao" class="com.ls.dao.UserDaoImpl" /> <bean id="userDaoTest1" class="com.ls.dao.UserDaoTest1Impl"/> <bean id="userDaoTest2" class="com.ls.dao.UserDaoTest2Impl"/> <!-- ref:引用Spring容器创建好的对象 value:具体的值。基本数据类型 --> <bean id="userService" class="com.ls.service.UserServiceImpl"> <property name="userDao" ref="userDaoTest1"/> </bean> </beans>
测试
@Test public void testBean() { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("userService"); userServiceImpl.getUser(); }
OK , 到了现在 , 我们彻底不用再程序中去改动了 , 要实现不同的操作 , 只需要在xml配置文件中进行修改 , 所谓的IoC,一句话搞定 : 对象由Spring 来创建 , 管理 , 装配 !
默认使用无参构造创建对象!
假设需要使用有参构造创建对象
下标赋值
<!-- 下标复制 --> <bean id="getUser" class="com.ls.pojo.User"> <constructor-arg index="0" value="learning Java."/> </bean>
通过类型创建
<!--2、通过类型创建--> <bean id="getUser" class="com.ls.pojo.User"> <constructor-arg type="java.lang.String" value="继续学Java。。。"/> </bean>
直接通过参数名来创建
<!--3、直接通过参数名来设置--> <bean id="getUser" class="com.ls.pojo.User"> <constructor-arg name="name" value="leishuai"/> </bean>
总结:在配置文件被加载的时候,容器中管理的对象就已经实例化了。
<!-- 别名,如果添加了别名,也可以通过别名获取到这个对象 --> <bean id="user" class="com.ls.pojo.User"> <constructor-arg name="name" value="leishuai"/> </bean> <!-- 别名,如果添加了别名,也可以通过别名获取到这个对象 --> <alias name="user" alias="newUser"/><alias name="user" alias="newUser"/>
<!-- id:Bean的唯一标识符,也就是相当于对象名 class:bean对象所对应的全限定名:包名 + 类型 name:也是别名,并且支持同时起多个别名 --> <bean id="car" class="com.ls.pojo.Car" name="c1 c2, c3;c4"> <property name="num" value="99999"/> </bean>
import一般用于团队开发使用,可以将多个配置文件导入合并为总的一个(applicationContext.xml),使用的时候,直接使用总的。
<import resource="beans1.xml"/> <import resource="beans2.xml"/> <import resource="beans3.xml"/>
依赖:指Bean对象的创建依赖于容器
注入:指Bean对象所依赖的资源,由容器来设置和装配
见上面的例子
要求被注入的属性必须有set方法
【环境搭建】
复杂类型
public class Address { private String Address; public String getAddress() { return Address; } public void setAddress(String address) { Address = address; } }
public class Student { private String name; private Address address; private String[] books; private List<String> hobbys; private Map<String, String> cards; private Set<String> games; private String wife; private Properties info; }
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"> <!-- 第一种、普通值注入,value --> <bean id="student" class="com.ls.pojo.Student"> <property name="name" value="张三"/> </bean> </beans>
测试
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="student" class="com.ls.pojo.Student"> <!-- 1、普通值注入,value --> <property name="name" value="吕布"/> <!-- 2、Bean注入,ref --> <property name="address" ref="address"/> <!-- 3、数组注入 --> <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="cards"> <map> <entry key="扣扣" value="9876543210"/> <entry key="电话号码" value="0123456789"/> <entry key="学号" value="0000000"/> </map> </property> <!-- Set --> <property name="games"> <set> <value>LOL</value> <value>COC</value> <value>BOB</value> </set> </property> <!-- null注入 --> <property name="wife"> <null></null> </property> <!-- Properties --> <property name="info"> <props> <prop key="username">小明</prop> <prop key="密码">123456</prop> </props> </property> </bean> <bean id="address" class="com.ls.pojo.Address"> <property name="address" value="五原郡九原县 "/> </bean> </beans>
结果:
public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); Student student = (Student) context.getBean("student"); System.out.println(student); /* Student{ name='吕布', address=Address{Address='五原郡九原县 '}, books=[西游记, 红楼梦, 三国演义, 水浒传], hobbys=[写代码, 玩游戏, 唱歌, 听音乐], cards={扣扣=9876543210, 电话号码=0123456789, 学号=0000000}, games=[LOL, COC, BOB], wife='null', info={密码=123456, username=小明} } */ }
p命名空间注入和c命名空间注入
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:c="http://www.springframework.org/schema/c" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd"> <!-- p命名空间注入,可以直接注入属性的值:property --> <bean id="user" class="com.ls.pojo.User" p:name="雷帅" p:age="23"></bean> <!-- c命名空间注入,通过构造器注入:construct-args --> <!-- 需在实体类中添加无参和有参构造方法 --> <bean id="user2" class="com.ls.pojo.User" c:name="明名" c:age="23"></bean> </beans>
测试:
@Test public void testUser() { ApplicationContext context = new ClassPathXmlApplicationContext("user.xml"); User user = context.getBean("user",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"
单例模式(Spring默认机制)
<bean id="user2" class="com.ls.pojo.User" c:name="明名" c:age="23" scope="singleton"></bean>
原型模式(每次从容器中get的时候,都会产生一个新的对象)
<bean id="user2" class="com.ls.pojo.User" c:name="明名" c:age="23" scope="prototype"></bean>
@Test public void testUser() { ApplicationContext context = new ClassPathXmlApplicationContext("user.xml"); User user = context.getBean("user2",User.class); User user2 = context.getBean("user2",User.class); System.out.println(user.hashCode());//40472007 System.out.println(user2.hashCode());//1138193439 System.out.println(user == user2);//false }
其余的request、session、application,这些只能在web开发中用到。
在Spring中有三种装配方式
环境搭建:一个人有两个宠物
public class Cat { public void shout() { System.out.println("miao~~"); } }
public class Dog { public void shout() { System.out.println("wang~~"); } }
public class Human { private Cat cat; private Dog dog; private String name; }
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="cat" class="com.ls.pojo.Cat"/> <bean id="dog" class="com.ls.pojo.Dog"/> <bean id="human" class="com.ls.pojo.Human"> <property name="cat" ref="cat"/> <property name="dog" ref="dog"/> <property name="name" value="吕布"/> </bean> </beans>
public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); Human human = context.getBean("human", Human.class); human.getCat().shout();//miao~~ human.getDog().shout();//wang~~ }
<bean id="cat" class="com.ls.pojo.Cat"/> <bean id="dog" class="com.ls.pojo.Dog"/> <!-- byName:会自动在容器上下文查找和自己set方法后面的值对应的bean的id。 --> <bean id="human" class="com.ls.pojo.Human" autowire="byName"> <property name="name" value="吕布"/> </bean>
<bean id="cat2" class="com.ls.pojo.Cat"/> <bean id="dog1" class="com.ls.pojo.Dog"/> <!-- byName:会自动在容器上下文查找和自己set方法后面的值对应的bean的id。 --> <!-- byType:会自动在容器上下文查找和自己对象属性类型相同的bean --> <bean id="human" class="com.ls.pojo.Human" autowire="byType"> <property name="name" value="吕布"/> </bean>
小结
要使用注解必须:
导入约束
xmlns:context="http://www.springframework.org/schema/context"
配置注解的支持
<!-- 开启注解 --> <context:annotation-config/>
@Autowired
直接在属性上使用即可,也可以在set方法上。
使用Autowired可以不在编写set方法,前提是这个自动装配的属性在IoC(Spring)容器中存在,且符合命名byName
科普:
@Nullable:字段标记了这个注解,说明这个字段可以为null
public @interface Autowired { boolean required() default true; }
测试:
public class Human { //如果显示的定义了Autowired的required属性为false,说明这个属性可以为null,否则不允许为空。 @Autowired(required = false) private Cat cat; @Autowired private Dog dog; private String name; }
如果Autowired的装配环境比较复杂,自动装配无法通过一个@Autowired完成的时候,我们可以使用@Qualifier(value = “xxx”)去配合@Autowired的使用,指定一个唯一Bean对象注入。
@Autowired(required = false) private Cat cat; @Autowired @Qualifier(value = "dog11") private Dog dog; private String name;
@Resource注解
@Resource private Cat cat; @Resource private Dog dog;
小结:
@Autowired和@Resource注解的区别:
Bean注入
//@Component 等价于 <bean id="user" class="com.ls.pojo.User"> @Component public class User { public String name = "张三"; }
<!-- 指定要扫描的包,这个包下的注解就会生效 --> <context:component-scan base-package="com.ls.pojo"/> <context:annotation-config/>
@Test public void UserTest() { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); User user = context.getBean("user",User.class); System.out.println(user.name);//张三 }
属性如何注入
@Component public class User { public String name; // @Value("lisi")//相当于<property name="name" value="lisi"> @Value("王五") public void setName(String name) { this.name = name; } @Override public String toString() { return "User{" + "name='" + name + '\'' + '}'; } }
@Component衍生的注解
自动装配置
@Autowired:自动装配通过类型。名字。 @Nullable:字段标记了这个注解,说明这个字段可以为null @Resource:自动装配通过名字。类型。
作用域 @Scope(“singleton”)
@Component @Scope("singleton") public class User { // @Value("lisi")//相当于<property name="name" value="lisi"> public String name; @Value("王五") public void setName(String name) { this.name = name; } @Override public String toString() { return "User{" + "name='" + name + '\'' + '}'; } }
小结
xml与注解:
xml与注解最佳实践:
xml用来管理Bean;
注解负责属性注入;
注意必须要让注解生效,需要开启注解的支持:
<!-- 指定要扫描的包,这个包下的注解就会生效 --> <context:component-scan base-package="com.ls"/> <!-- 开启注解 --> <context:annotation-config/>
现在完全不使用Spring的xml配置了,全权交给Java来做
JavaConfig是Spring的一个子项目,在Spring 4之后,它成为了一个核心功能。
实体类:
//注解说明这个类被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 + '\'' + '}'; } }
配置文件:
//@Configuration代表这是一个配置类,就和之前的applicationContext.xml一样的 //这个也会被Spring容器托管,注册到容器中,因为它本来就是一个@Component @Configuration @ComponentScan("com.ls.pojo") @Import(LeiConfig2.class) public class LeiConfig { //注册一个Bean就相当于写了一个bean标签,id为方法名,方法的返回值为class属性 @Bean public User needUser() { return new User();//返回要注入到Bean的对象。 } } /* 注意:1、如果开启包扫描,加载配置类以后就可以通过反射拿到配置类中的对象 2、@Bean只写在方法上,返回的是一个对象,但一般不获取已经在容器中的对象 3、@Bean可以用于通过方法获取数据库连接池Connection这种对象 */
测试类:
public static void main(String[] args) { //如果完全使用了配置类方式去做,就只能通过ApplicationContext上下文来获取容器,,通过配置类的class加载对象 ApplicationContext context = new AnnotationConfigApplicationContext(LeiConfig.class); User user = context.getBean("needUser",User.class); System.out.println(user.getName()); }
这种纯Java的配置方式,在SpringBoot中随处可见!
代理模式就是SpringAOP的底层!【SpringAOP和SpringMVC】
代码步骤:
接口
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() { seeHouse(); heTong(); fare(); host.rent(); } //看房 public void seeHouse() { System.out.println("中介带你看房"); } //合同 public void heTong() { 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(); } }
代理模式的好处:
缺点:
接口
public interface UserService { public void add(); public void delete(); public void update(); public void query(); }
真实角色
public class UserServiceImpl implements UserService { @Override public void add() { System.out.println("调用了UserServiceImpl的add()。"); } @Override public void delete() { System.out.println("调用了UserServiceImpl的delete()。"); } @Override public void update() { System.out.println("调用了UserServiceImpl的update()。"); } @Override public void query() { System.out.println("调用了UserServiceImpl的query()。"); } }
代理角色
public class UserProxy implements UserService { private UserServiceImpl userService; public void setUserService(UserServiceImpl userService) { this.userService = userService; } @Override public void add() { log("add"); userService.add(); } @Override public void delete() { log("delete"); userService.delete(); } @Override public void update() { log("update"); userService.update(); } @Override public void query() { log("query"); userService.query(); } private void log(String msg) { System.out.println("使用了" + msg + "方法"); } }
客户端
public class Client { public static void main(String[] args) { UserServiceImpl service = new UserServiceImpl(); UserProxy proxy = new UserProxy(); proxy.setUserService(service); proxy.add(); } }
AOP中最核心的思想:在不改变原代码的方式下,实现了对原有功能的增强。
纵向开发,横向开发。
需要了解两个类:Proxy(代理):生成动态代理实例
InvocationHandler:调用处理程序并返回一个结果
接口
public interface Rent { public void rent(); }
真实角色
public class Host implements Rent { @Override public void rent() { System.out.println("房东要出租房子。"); } }
处理程序(此处并不是代理角色,而是实现InvocationHandler的一个处理程序)
//实现了InvocationHandler的一个处理程序 // 动态代理没有真实的代理角色,有的只是一个实现了InvocationHandler的处理程序 public class ProxyInvocationHandler implements InvocationHandler { //被代理的接口 private Rent rent; public void setRent(Rent rent) { this.rent = rent; } /* newProxyInstance( java.lang.ClassLoader, //先获得反射对象,在获得类加载器,找到要代理的类的位置 java.lang.Class<?>[], // 要得到代理类的接口 java.lang.reflect.InvocationHandler //因为本类实现了InvocationHandler接口,所以只需传个this ) */ //生成得到代理类 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(); //反射,用invoke来执行方法执行 //动态代理的本质就是 使用反射机制来实现 Object result = method.invoke(rent, args); fare(); return result; } private void seeHouse() { System.out.println("中介带看房子"); } private void fare() { System.out.println("中介收取费用"); } }
客户
public class Client { public static void main(String[] args) { //真实角色 Host host = new Host(); /* 代理角色(现在没有) ProxyInvocationHandler不是代理类,而是一个处理程序,现在需要用ProxyInvocationHandler来生成一个代理类 */ ProxyInvocationHandler pih = new ProxyInvocationHandler(); //通过调用程序处理角色来调用我们要调用的接口对象 //真实角色和代理角色都要实现共同的接口 pih.setRent(host); //这里的proxy就是动态生成的,并没有写具体的类 Rent proxy = (Rent) pih.getProxy(); proxy.rent(); } }
动态代理的好处:
AOP(Aspect Oriented Programming)意为:面向切面编程,通过预编译的方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生泛型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑之间的耦合性大大降低,提高程序的可重用性,同时提高了开发的效率。
AOP是一种横向编程的思想,在不影响原来业务类的情况下,实现业务的增强。
提供声明式事务,允许用户自定义切面。
导入依赖
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver --> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.6</version> <scope>runtime</scope> </dependency>
方式一:使用Spring的API接口【主要是SpringAPI】
设置前置
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() + "被执行了"); } }
执行方法之后
public class AfterLog implements AfterReturningAdvice { @Override public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable { System.out.println("执行了" +method.getName() + "方法,返回结果为" + returnValue); } }
配置applicationContext.xml
<!-- 注册bean --> <bean id="userService" class="com.ls.service.UserServiceImpl"></bean> <bean id="log" class="com.ls.log.Log"/> <bean id="afterLog" class="com.ls.log.AfterLog"/> <!-- 配置AOP:需要导入AOP的配置 --> <aop:config> <!--切入点 expression表达式 execution中添加要执行的位置--> <aop:pointcut id="pointcut" expression="execution(* com.ls.service.UserServiceImpl.*(..))"/> <!-- 执行环绕增强 --> <aop:advisor advice-ref="log" pointcut-ref="pointcut"/> <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/> </aop:config>
测试
public class MyTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); //动态代理代理的是接口 UserService service = (UserService) context.getBean("userService"); service.insert(); } }
结果
方式二:自定义切面类【主要是自定义切面】
自定义切面类
public class DiyPointCut { public void before() { System.out.println("----------------方法执行之前-------------------"); } public void after() { System.out.println("----------------方法执行之前-------------------"); } }
配置applicationContext.xml
<!-- 方式二:自定义切面类 --> <bean id="diyPointCut" class="com.ls.diy.DiyPointCut"></bean> <aop:config> <!-- 自定义切面 ref:要引用的类(标记这个类为切面) --> <aop:aspect ref="diyPointCut"> <aop:pointcut id="point" expression="execution(* com.ls.service.UserServiceImpl.*(..))"/> <!-- 通知 --> <aop:before method="before" pointcut-ref="point"/> <aop:after method="after" pointcut-ref="point"/> </aop:aspect> </aop:config>
测试方法不变
public class MyTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); //动态代理代理的是接口 UserService service = (UserService) context.getBean("userService"); service.insert(); } }
结果
方式三:注解实现
添加一个切面
@Aspect//标记这个类是一个切面 public class AnnotationPointCut { @Before("execution(* com.ls.service.UserServiceImpl.*(..))") public void before() { System.out.println("==========方法执行之前========="); } @After("execution(* com.ls.service.UserServiceImpl.*())") public void after() { System.out.println("============方法执行之后==========="); } //在环绕增强中,我们可以给定一个参数,代表我们要获取处理切入的点 @Around("execution(* com.ls.service.UserServiceImpl.*())") public void around(ProceedingJoinPoint pjp) throws Throwable { System.out.println("环绕前"); Object proceed = pjp.proceed();//执行方法 System.out.println("环绕后"); System.out.println(pjp.getSignature()); } }
添加注解支持
<!-- 方式三、注解实现 --> <bean id="annotationPointCut" class="com.ls.diy.AnnotationPointCut"/> <!-- 开启注解支持 JDK默认:(roxy-target-class="false") cglib(proxy-target-class="true")--> <aop:aspectj-autoproxy/>
测试类
public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); //动态代理代理的是接口 UserService service = (UserService) context.getBean("userService"); service.insert(); }
结果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6Au1YcFv-1637374787374)(D:\Typora\img\image-20211027105629919.png)]
编写数据源
<!-- DataSource:使用Spring的数据源替换mybatis的位置 --> <!-- 这里使用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=false&serverTimezone=Hongkong&characterEncoding=utf-8&autoReconnect=true"/> <property name="username" value="root"/> <property name="password" value="171684"/> </bean>
sqlSessionFactory
<!-- SqlSessionFactoryBean --> <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/ls/mapper/*.xml"/> </bean>
sqlSessionTemplate
<!-- SqlSessionTemplate:就是要使用的SqlSession --> <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"> <!-- 只能使用构造器注入sqlSessionFactory,因为它没有Set方法 --> <constructor-arg index="0" ref="sqlSessionFactory"/> </bean>
需给接口添加实现类
public class UserMapperImpl implements UserMapper { private SqlSessionTemplate sqlSession; public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) { this.sqlSession = sqlSessionTemplate; } @Override public List<User> getUserList() { UserMapper mapper = sqlSession.getMapper(UserMapper.class); return mapper.getUserList(); } }
将实现类注入到Spring中
<bean id="userMapper" class="com.ls.mapper.UserMapperImpl"> <property name="sqlSessionTemplate" ref="sqlSession"/> </bean>
测试类使用即可
public static void main(String[] args) throws IOException { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); UserMapper userMapper = context.getBean("userMapper", UserMapper.class); for (User user : userMapper.getUserList()) { System.out.println(user); } }
第二种方式整合(extends SqlSessionDaoSupport)
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper { @Override public List<User> getUserList() { return getSqlSession().getMapper(UserMapper.class).getUserList(); } }
<!-- DataSource:使用Spring的数据源替换mybatis的位置 --> <!-- 这里使用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=false&serverTimezone=Hongkong&characterEncoding=utf-8&autoReconnect=true"/> <property name="username" value="root"/> <property name="password" value="171684"/> </bean> <!-- SqlSessionFactoryBean --> <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/ls/mapper/*.xml"/> </bean> <bean id="userMapper2" class="com.ls.mapper.UserMapperImpl2"> <property name="sqlSessionFactory" ref="sqlSessionFactory"/> </bean>
事务(transaction)ACID原则
原子性
事务是数据库的逻辑工作单位,事务中包含的各操作要么都成功,要么都失败
一致性
事务执行的结果必须是使数据库从一个一致性状态变到另一个一致性状态。
隔离性
一个事务的执行不能被其它事务干扰。即一个事务内部的操作及使用的数据对其它并发事务是隔离的,并发执行的各个事务之间不能互相干扰。
持续性
也称永久性,指一个事务一旦提交,它对数据库中的数据的改变就是永久性的。接下来的其它操作或故障不应该对其执行结果有任何影响。
<!-- 配置声明式事务 --> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"/> </bean> <!-- 结合AOP实现事务的织入 --> <tx:advice id="txAdvice" transaction-manager="transactionManager"> <!-- 给那些方法配置事务 --> <!-- 配置事务的传播特性 --> <tx:attributes> <tx:method name="add" propagation="REQUIRED"/> <tx:method name="delete" propagation="REQUIRED"/> <tx:method name="update" propagation="REQUIRED"/> <tx:method name="*" propagation="REQUIRED"/> </tx:attributes> </tx:advice> <!-- 配置事务切入 --> <aop:config> <!-- 切入点 --> <aop:pointcut id="txPointCut" expression="execution(* com.ls.mapper.*.*(..))" /> <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/> </aop:config>
思考:为什么需要事务?