Spring
简介
- 雏形:interface21
- 诞生:2004年3月24日
- 理念:使现有的技术更加容易使用,本身是大杂烩,整合了现有的技术框架。
- spring web mvc
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.9</version>
</dependency>
优点
- 开源免费框架
- 非入侵式,轻量级
- 控制反转(IOC),面向切面编程(AOP)
- 支持事务的处理,对框架整合的支持
组成
拓展
Spring Boot
- 一个快速开发的脚手架
- 基于Spring Boot可以快速开发单个微服务
- 约定大于配置
SpringCloud
- Spring Cloud是基于Spring Boot实现的
大部分公司都在使用Spring Boot开发,Spring和Spring MVC是学习的前提
IOC
ioc原型(控制反转)
利用set实现动态值注入,发生了革命性变化
// 利用set实现动态值注入
public void setUserDao(UserDao userDao){
this.userDao = userDao;
}
}
- 之前程序是主动创建对象,控制权在程序员手上
- 使用set注入后,程序不再具有主动性,而是变成被动接受对象。
控制反转是一种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IOC容器,其实现方法是依赖注入。
Hello Spring
结构如图
Hello.java
package top.huii.pojo;
public class Hello {
private String str;
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
@Override
public String toString() {
return "Hello{" +
"str='" + str + '\'' +
'}';
}
}
配置文件beans.xml(可使用IDEA生成模板)
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--
bean = 对象 new Hello()
property相当于给内容赋值
-->
<bean id="Hello" class="top.huii.pojo.Hello">
<property name="str" value="Spring"/>
</bean>
</beans>
测试文件MyTest.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import top.huii.pojo.Hello;
public class MyTest{
public static void main(String[] args) {
// 获取spring的上下文对象
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Hello hello = (Hello) context.getBean("Hello");
System.out.println(hello.toString());
}
}
IOC创建对象的方法
1 使用无参构造创建对象。默认
2 有参构造
①下标赋值
<bean id="exampleBean" class="examples.ExampleBean">
<constructor-arg index="0" value="7500000"/>
<constructor-arg index="1" value="42"/>
</bean>
② 参数类型匹配(不建议使用)
<bean id="exampleBean" class="examples.ExampleBean">
<constructor-arg type="int" value="7500000"/>
<constructor-arg type="java.lang.String" value="42"/>
</bean>
③通过参数名设置
<bean id="exampleBean" class="examples.ExampleBean">
<constructor-arg name="years" value="7500000"/>
<constructor-arg name="ultimateAnswer" value="42"/>
</bean>
Spring配置
别名
<alias name="fromName" alias="toName"/>
Bean配置
<bean id="exampleBean" class="examples.ExampleBean" name="user user2,user3;user4">
<property name="integerProperty" value="1"/>
</bean>
import
ApplicationContext.xml
<beans>
<import resource="services.xml"/>
<import resource="resources/messageSource.xml"/>
<import resource="/resources/themeSource.xml"/>
<bean id="bean1" class="..."/>
<bean id="bean2" class="..."/>
</beans>
依赖注入
构造器注入
上面已经说过
set方式注入(*)
依赖
bean的创建依赖于容器
注入
bean对象中的所有属性,由容器来注入
代码
Address.java
package top.huii.pojo;
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Address{" +
"address='" + address + '\'' +
'}';
}
}
Student.java
package top.huii.pojo;
import java.util.*;
public class Student {
private String name;
private Address address;
private String[] books;
private List<String> hobbies;
private Map<String, String> card;
private Set<String> games;
private String wife;
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> getHobbies() {
return hobbies;
}
public void setHobbies(List<String> hobbies) {
this.hobbies = hobbies;
}
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 getWife() {
return wife;
}
public void setWife(String wife) {
this.wife = wife;
}
public Properties getInfo() {
return info;
}
public void setInfo(Properties info) {
this.info = info;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", address=" + address.toString() +
", books=" + Arrays.toString(books) +
", hobbies=" + hobbies +
", card=" + card +
", games=" + games +
", wife='" + wife + '\'' +
", info=" + 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.xsd">
<bean id="address" class="top.huii.pojo.Address">
<property name="address" value="合肥"/>
</bean>
<bean id="student" class="top.huii.pojo.Student">
<!--普通类,value-->
<property name="name" value="HUII"/>
<!--Bean注入-->
<property name="address" ref="address"/>
<!--数组注入-->
<property name="books">
<array>
<value>红楼梦</value>
<value>西游记</value>
<value>水浒传</value>
<value>三国演义</value>
</array>
</property>
<!--list-->
<property name="hobbies">
<list>
<value>听歌</value>
<value>代码</value>
</list>
</property>
<!--map-->
<property name="card">
<map>
<entry key="身份证" value="11111111111111111111111"/>
</map>
</property>
<!--set-->
<property name="games">
<set>
<value>LOL</value>
<value>qqfc</value>
</set>
</property>
<!--null-->
<property name="wife">
<null/>
</property>
<!--properties-->
<property name="info">
<props>
<prop key="学号">2019210001</prop>
<prop key="国籍">中国</prop>
</props>
</property>
</bean>
</beans>
MyTest.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import top.huii.pojo.Student;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student student = (Student) context.getBean("student");
// System.out.println(student.getName());
System.out.println(student.toString());
}
}
扩展方式
p命名空间
user.java
package top.huii.pojo;
public class User {
private String name;
private int age;
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
userbeans.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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--p命名空间可以直接注入属性-->
<bean id="user" class="top.huii.pojo.User" p:age="18" p:name="HUII"/>
</beans>
测试
public class MyTest {
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
User user = (User) context.getBean("user");
System.out.println(user);
}
}
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:c="http://www.springframework.org/schema/c"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--c命名空间,通过构造器注入-->
<bean id="user2" class="top.huii.pojo.User" c:age="19" c:name="huii"/>
</beans>
bean的作用域
单例模式(默认)
只有一个对象
<bean id="accountService" class="com.foo.DefaultAccountService"/>
<!-- the following is equivalent, though redundant (singleton scope is the default) -->
<bean id="accountService" class="com.foo.DefaultAccountService" scope="singleton"/>
原型模式
每次从容器中get的时候,都会产生一个新对象
<bean id="accountService" class="com.foo.DefaultAccountService" scope="prototype"/>
其他
request,session,application只能在web开发中使用
Bean的自动装配
自动寻找并装配属性
配置的三种方式
- xml中显式配置
- java中显式配置
- 隐式自动装配bean(*)
准备代码
cat.java
package top.huii.pojo;
public class Cat {
public void shout(){
System.out.println("miao");
}
}
dog.java
package top.huii.pojo;
public class Dog {
public void shout(){
System.out.println("wang");
}
}
people.java
package top.huii.pojo;
public class People {
private Cat cat;
private Dog dog;
private String name;
public Cat getCat() {
return cat;
}
public void setCat(Cat cat) {
this.cat = cat;
}
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "People{" +
"cat=" + cat +
", dog=" + dog +
", name='" + name + '\'' +
'}';
}
}
测试
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import top.huii.pojo.People;
public class MyTest {
@Test
public void test1(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
People people = context.getBean("people", People.class);
people.getCat().shout();
people.getDog().shout();
}
}
byName自动装配
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="cat" class="top.huii.pojo.Cat"/>
<bean id="dog" class="top.huii.pojo.Dog"/>
<!--byName会自动在容器上下文中查找和自己对象set方法后面的值对应的beanid-->
<bean id="people" class="top.huii.pojo.People" autowire="byName">
<property name="name" value="HUII"/>
<!-- <property name="cat" ref="cat"/>-->
<!-- <property name="dog" ref="dog"/>-->
</bean>
</beans>
需要保证所有的bean的id唯一,且这个bean需要和自动注入的属性的set方法的值一致。
byType自动装配
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="cat" class="top.huii.pojo.Cat"/>
<bean id="dog" class="top.huii.pojo.Dog"/>
<!--byType会自动在容器上下文中查找和自己对象相同类型的bean-->
<bean id="people" class="top.huii.pojo.People" autowire="byType">
<property name="name" value="HUII"/>
<!-- <property name="cat" ref="cat"/>-->
<!-- <property name="dog" ref="dog"/>-->
</bean>
</beans>
byType甚至可以省略id
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean class="top.huii.pojo.Cat"/>
<bean class="top.huii.pojo.Dog"/>
<!--byName会自动在容器上下文中查找和自己对象set方法后面的值对应的beanid-->
<!--byType会自动在容器上下文中查找和自己对象相同类型的bean-->
<bean id="people" class="top.huii.pojo.People" autowire="byType">
<property name="name" value="HUII"/>
<!-- <property name="cat" ref="cat"/>-->
<!-- <property name="dog" ref="dog"/>-->
</bean>
</beans>
需要保证所有的bean的class唯一,且这个bean需要和自动注入的属性的类型一致。
使用注解实现自动装配
- 导入约束 content约束
- 配置注解的支持
<?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/>
<bean class="top.huii.pojo.Cat"/>
<bean class="top.huii.pojo.Dog"/>
<bean id="people" class="top.huii.pojo.People"/>
</beans>
可以省去很多配置,甚至set可以省去
People.java
package top.huii.pojo;
import org.springframework.beans.factory.annotation.Autowired;
public class People {
@Autowired
private Cat cat;
@Autowired
private Dog dog;
private String name;
public Cat getCat() {
return cat;
}
public Dog getDog() {
return dog;
}
public String getName() {
return name;
}
@Override
public String toString() {
return "People{" +
"cat=" + cat +
", dog=" + dog +
", name='" + name + '\'' +
'}';
}
}
@Autowired
直接在属性上使用即可。也可以在set方式上使用。可不写set。
@Nullable
表明字段可为空
public class SimpleMovieLister {
@Inject
public void setMovieFinder(@Nullable MovieFinder movieFinder) {
...
}
}
@Autowired
较为复杂时,可以使用@Qualifier
指定唯一bean对象注入
@Resource
public class SimpleMovieLister {
private MovieFinder movieFinder;
@Resource(name="myMovieFinder")
public void setMovieFinder(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}
}
使用注解开发
使用注解需要导入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>
使用@Component
配置文件
<?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:component-scan base-package="top.huii.dao"/>
<context:annotation-config/>
</beans>
User.java
package top.huii.dao;
import org.springframework.stereotype.Component;
//等价于在配置文件中进行配置
@Component
public class User {
public String name = "HUII";
}
@Value属性注入
@Component
public class User {
@Value("HUII")
public String name = "HUII";
}
衍生注解
@Component有几个衍生注释
UserDao.java
package top.huii.dao;
import org.springframework.stereotype.Repository;
@Repository
public class UserDao {
}
UserService
package top.huii.service;
import org.springframework.stereotype.Service;
@Service
public class UserService {
}
UserControl.java
package top.huii.controller;
import org.springframework.stereotype.Controller;
@Controller
public class UserControl {
}
配置文件
<?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:component-scan base-package="top.huii"/>
<context:annotation-config/>
</beans>
几个功能都表示将某个类注册到Spring中
作用域@Scope
@Component
public class FactoryMethodComponent {
@Bean @Scope("prototype")
public TestBean prototypeInstance(InjectionPoint injectionPoint) {
return new TestBean("prototypeInstance for " + injectionPoint.getMember());
}
}
小结
- xml更万能,适合任何场合,维护方便
- 注解不是自己类使用不了,维护复杂
使用Java的方式配置spring
JavaConfig
User.java
package top.huii.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class User {
private String name;
public String getName() {
return name;
}
@Value("HUII")
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
配置文件MyConfig.java
package top.huii.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import top.huii.pojo.User;
@Configuration
public class MyConfig {
// 注册一个bean相当于bean标签
// 方法名字相当于id,返回值相当于class
@Bean
public User getUser(){
return new User();
}
}
MyTest.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import top.huii.config.MyConfig;
import top.huii.pojo.User;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
User getUser = (User) context.getBean("getUser");
System.out.println(getUser.getName());
}
}
这种纯java配置的方法在SpringBoot中随处可见
代理模式
静态代理
Rent.java
package top.huii.demo1;
public interface Rent {
public void rent();
}
Host.java
package top.huii.demo1;
public class Host implements Rent{
public void rent() {
System.out.println("房东要出租房子");
}
}
Proxy.java
package top.huii.demo1;
public class Proxy implements Rent{
private Host host;
public Proxy(){
}
public Proxy(Host host){
this.host = host;
}
public void rent() {
seeHouse();
host.rent();
heTong();
}
public void seeHouse(){
System.out.println("看房");
}
public void heTong(){
System.out.println("签合同");
}
}
Client.java
package top.huii.demo1;
public class Client {
public static void main(String[] args) {
Host host = new Host();
Proxy proxy = new Proxy(host);
proxy.rent();
}
}
优点
- 使真实角色的操作更纯粹,不用去关心一些公共事务
- 公共事务交给代理角色,实现了业务的分工
- 公共业务发生拓展是方便集中管理
缺点
- 一个真实角色就会产生一个代理角色,代码量翻倍,开发效率降低
动态代理
- 动态代理与静态代理角色一样
- 动态代理的代理类是动态生成的,不是我们直接写好的
- 动态代理分为两大类:①基于接口——基于JDK ②基于类cglib
需要理解两个类:Proxy和InvocationHandler
ProxyInvocationHandler.java
package top.huii.demo2;
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);
}
// 处理代理实例,并返回结果
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
// 本质使用代理
Object result = method.invoke(target, args);
return result;
}
}
优点:一个动态代理类可代理同一类业务
AOP
面向切面编程
依赖包
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.7</version>
<scope>runtime</scope>
</dependency>
使用原生Spring API实现
UserService.java
package top.huii.service;
public interface UserService {
public void add();
public void delete();
public void update();
public void select();
}
UserServiceImpl.java
package top.huii.service;
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 select() {
System.out.println("查询一个用户");
}
}
Log.java
package top.huii.log;
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
public class Log implements MethodBeforeAdvice {
// method:要执行的目标对象方法
// args: 参数
public void before(Method method, Object[] objects, Object o) throws Throwable {
System.out.println(o.getClass().getName()+"的"+method.getName()+"被执行了");
}
}
AfterLog.java
package top.huii.log;
import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
public class AfterLog implements AfterReturningAdvice {
public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
System.out.println("执行了"+method.getName()+"返回结果为"+o);
}
}
配置文件
<?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
http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="userService" class="top.huii.service.UserServiceImpl"/>
<bean id="log" class="top.huii.log.Log"/>
<bean id="afterLog" class="top.huii.log.AfterLog"/>
<!-- 配置aop-->
<aop:config>
<!--切入点-->
<aop:pointcut id="pointcut" expression="execution(* top.huii.service.UserServiceImpl.*(..))"/>
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>
</beans>
测试文件
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import top.huii.service.UserService;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = context.getBean("userService", UserService.class);
userService.add();
}
}
自定义类
DiyPointCut.java
package top.huii.diy;
public class DiyPointCut {
public void before() {
System.out.println("=====方法执行前=====");
}
public void after() {
System.out.println("=====方法执行后=====");
}
}
配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="userService" class="top.huii.service.UserServiceImpl"/>
<bean id="log" class="top.huii.log.Log"/>
<bean id="afterLog" class="top.huii.log.AfterLog"/>
<!--方式二:自定义类-->
<bean id="diy" class="top.huii.diy.DiyPointCut"/>
<aop:config>
<aop:aspect ref="diy">
<!--切入点-->
<aop:pointcut id="point" expression="execution(* top.huii.service.UserServiceImpl.*(..))"/>
<aop:before method="before" pointcut-ref="point"/>
<aop:after method="after" pointcut-ref="point"/>
</aop:aspect>
</aop:config>
</beans>
注解实现
AnnotationPointCut.java
package top.huii.diy;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect
public class AnnotationPointCut {
@Before("execution(* top.huii.service.UserServiceImpl.*(..))")
public void before(){
System.out.println("=====方法执行前=====");
}
}
配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="userService" class="top.huii.service.UserServiceImpl"/>
<bean id="log" class="top.huii.log.Log"/>
<bean id="afterLog" class="top.huii.log.AfterLog"/>
<!--方式三:注解-->
<bean id="annotationPointCut" class="top.huii.diy.AnnotationPointCut"/>
<aop:aspectj-autoproxy/>
</beans>
整合Mybatis
基本环境搭建
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>learn_spring1</artifactId>
<groupId>top.huii</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>Mybatis-spr</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.49</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.9</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.9</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.7</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.6</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.20</version>
</dependency>
</dependencies>
</project>
Mybatis
参考之前的
MyBatis-Spring
方式一
出问题了。。。
声明式事务
确保完整性和一致性
事务的ACID原则
- 原子性
- 一致性
- 隔离性
- 持久性
。。。
【完】