Spring中的IOC和AOP以及Spring中的声明式事务

Spring中的IOC和AOP以及Spring中的声明式事务(基于狂神说Java-Spring)

Spring中的IOC

IOC(Inversion Of Controller)又称控制反转,是一种通过(xml或者注解)并通过第三方生成或获取特定对象的方式,在Spring中实现控制反转的是IOC容器,其实现方法是依赖注入(DI:Dependency Injection)

  • 控制:控制对象的创建,传统的Java面向对象编程,对象是由程序本身控制实现创建的。用了Spring之后,对象都是由Spring来进行创建的
  • 反转:程序现在不用自己创建对象,而是自己被动的接收一个对象

总结:所谓的控制反转,就是创建对象的方式反转了,总的来说,对象可以交给Spring容器进行创建,管理,装配

Spring 当中的依赖

 <dependencies>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-webmvcartifactId>
        <version>5.2.7.RELEASEversion>
    dependency>
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
    dependency>
dependencies>

注解说明

  • @Autowired:Spring注解自动装配,可以通过类型和名字,但是当Bean实例多于两个时无法装配,需要通过@Quefilier注解配合使用指定某个Bean实例(注意:@Qualifier不能单独使用),如果允许对象为null,设置required = false,required属性默认为true,即为**@Autowired(required = false)**
  • @Nullable:如果某个字段标记了这个注解后,说明这个字段可以为null
  • @Resource:此注解是JavaEE原生注解实现,同样可以实现自动装配,在Bean实例多于两个时可以通过name属性指定Bean实例(但是这边有一个小问题,随着JDK版本的提升,JavaEE原生注解就不再支持,所以在高版本的JDK中还需要导入相关的Maven依赖),@Resource会通过name属性进行查找,如果说查找不到才会通过Bean的类型进行查找。
 <dependency>
   <groupId>javax.annotationgroupId>
   <artifactId>javax.annotation-apiartifactId>
   <version>1.3.2version>
 dependency>
  • @Component:组件,使用此注解声明当前Java类交由Spring进行管理(在此注解的基础上还增加了三个衍生注解,基于MVC三层架构)

    • @Repository:dao层注解
    • @Service:Service层注解
    • @Controller:Controller层注解

注意事项:翻阅底层源码可以发现这四个注解的代码都是一样的,意味着他们的功能都是一样的,都是代表将某个类交由Spring托管,进行Bean的装配

对于xml和注解:

  • xml配置在有些情况下会较为复杂,但是xml文件配置适用于任何场合
  • 注解,对于注解,它的作用范围最大只能在当前这个Java类中,无法延伸到其他的类其他的包中,并且在后期项目维护极为不便

所以针对这种情况最直接的解决方案就是两种方式进行组合(最佳实现)

  • xml用来对Bean进行统一的管理
  • 注解用来对属性进行注入处理
  • 在使用的过程中,必须要让注解生效,就需要在xml中进行开启注解支持

<context:component-scan base-package="com.hrc"/>
<context:annotation-config/>

回顾代理模式

SpringAOP(Aspect Oriented Programming)的底层就是代理设计模式!!!

代理模式有两种:静态代理和动态代理

静态代理

业务分析:

  • 抽象角色:一般都会用接口(使用较多)或者是抽象类来解决
// 以租房为例实现静态代理
public interface Rent {
    void rent();
}
  • 真实角色:处理真实业务,同时被代理角色进行代理
// 房东
public class Host implements Rent {
    @Override
    public void rent() {
        System.out.println("房东要出租房子(真实业务)");
    }
}
  • 代理角色:代理真实角色,并且实现属于自己的扩展业务
public class MiddleProxy extends Host {
    // 处理真实业务
    public void rent() {
        this.rentBefore();
        super.rent(); // 真实业务
        this.rentAfter();
        this.res();
    }
    // 实现扩展业务
    public void rentBefore() {
        System.out.println("中介接单");
    }
    public void rentAfter() {
        System.out.println("中间商赚差价");
    }
    public void res() {
        System.out.println("扩展业务完成");
    }
}
  • 用户:访问代理对象
public class Client {
    public static void main(String[] args) {
        // 代理角色,中介帮房东租房子,但是中介会做一些房东不会做的扩展业务
        MiddleProxy proxy = new MiddleProxy();
        proxy.rent();
    }
}

代理模式的好处:

  • 可以让真实业务操作变得更加纯粹,说白了就是“我”该干嘛就干嘛,不用去关心其他的扩展业务
  • 公共业务就交给了其他的代理角色,实现业务的分工处理
  • 公共业务延伸出其他的扩展业务时,方便集中进行管理

缺点:

  • 一个真实业务就需要一个代理对象进行代理,一旦真实业务多了之后,代码量提升就会造成冗余,开发效率降低

动态代理

业务分析:

  • 抽象角色:与静态代理相同

  • 代理角色:动态生成,不是由开发者自己编写,而是开发者自定义一个模板然后交给程序去生成代理对象

  • 动态代理的实现机制有两种:一种是基于接口的动态代理,还有一种就是基于cglib实现动态代理

    • 基于接口:JDK动态代理
    • 基于类的动态代理,也就是cglib动态代理(需要导入额外的cglib相关依赖)
    • Java字节码实现动态代理:Javassist

首先需要熟悉两个Java类:Proxy:代理;InvocationHandler:调用处理程序

动态代理的好处:

  • 静态代理的优点全部具备
  • 一个动态代理类代理的是一个接口,一般就是对应其某一个类型的业务,而不是单个业务
  • 一个动态代理类可以代理多个类,只要是实现了同一个接口即可

优化之前实现的房东买房子的业务操作

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);
    }
    /**
     * 处理代理实例,并返回结果
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        // 动态代理的本质就是使用反射机制实现
        Object res = method.invoke(target, args);
        return res;
    }
    public void log(String msg) {
        System.out.println("【INFO】" + msg);
    }
}
public class Client {
    public static void main(String[] args) {
        // 真实业务主题
        Host host = new Host();
        // 生成代理角色
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(host); // 设置代理对象
        // 动态生成代理类
        Rent proxy = (Rent) pih.getProxy();
        proxy.rent();
    }
}

SpringAOP

AOP(Aspect Oriented Programming),意思是面向切面编程,它是OOP(Object-Oriented Programming 面向对象编程)的一种延续
在不破坏原有代码实现的基础上,利用“织入”的模式来实现一些代码的动态配置
利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高代码可重用性,提高开发效率

使用SpringAOP需要额外导入相关依赖


<dependency>
    <groupId>org.aspectjgroupId>
    <artifactId>aspectjweaverartifactId>
    <version>1.9.5version>
dependency>

实现AOP的方式之一:使用Spring的接口

主要是通过实现Spring的接口来进行切面的处理

public interface UserService {
    void insert();
    void delete();
    void update();
    void select();
}
/*--------------两个类分开写----------------*/
public class UserServiceImpl implements UserService {
    @Override
    public void insert() {
        System.out.println("【INSERT】增加了一个用户");
    }
    @Override
    public void delete() {
        System.out.println("【DELETE】删除了一个用户");
    }
    @Override
    public void update() {
        System.out.println("【UPDATE】修改了一个用户");
    }
    @Override
    public void select() {
        System.out.println("【SELECT】查询了一个用户");
    }
}
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
public class Log implements MethodBeforeAdvice {
    /**
     * 在实现操作业务之前首先要先做一些日志信息
     * @param method 要执行的目标对象的方法
     * @param objects 参数,对象数组
     * @param target 目标对象
     * @throws Throwable
     */
    @Override
    public void before(Method method, Object[] objects, Object target) throws Throwable {
        System.out.println(target.getClass().getName() + "的" + method.getName() + "被执行了");
    }
}
import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
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);
    }
}

<bean id="userService" class="com.hrc.service.UserServiceImpl"/>
<bean id="log" class="com.hrc.log.Log"/>
<bean id="afterLog" class="com.hrc.log.AfterLog"/>

<aop:config>
    
    <aop:pointcut id="pointcut" expression="execution(public * com.hrc.service..*(..))"/>
    <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
    <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
aop:config>

这里有一个小东西叫做AspectJ表达式,Spring容器中支持此表达式,用来进行切入点的定义

其语法格式为:方法注解 权限修饰符 返回值 全限定类名 方法名 (参数);这里有几个地方需要注意

  • 方法注解:可选操作,即一个方法上的注解,例如@Override
  • 权限修饰符:public,protected,default(权限修饰符为可选操作,即可有可无)
  • 返回值:有多种,这里可以用 * 来表示这个表达式的返回值为任意返回值
  • 全限定类名:其名称格式为,包.类名称;如果这个包下面还有子包,可以使用“…”来代替所有的子包
  • 方法名:普通普通的方法名称,这边可以和全限定类名进行组合,所以总的名称格式可以为包.类名称.方法名(参数)
  • (参数):括号里可以使用“…”来表示任意的参数
import com.hrc.service.UserService;
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 service = context.getBean("userService", UserService.class);
        service.insert();
    }
}

SpringAOP的实现方式二:自定义类实现 AOP

自定义类实现AOP只需要编写自定义类,无需实现Spring自带的接口,通过配置文件进行切面的处理配置

public class MyselfClass {
    public void before() {
        System.out.println("【INFO---BEFORE】业务处理之前");
    }
    public void after() {
        System.out.println("【INFO---AFTER】业务处理之后");
    }
}
<bean id="myselfClass" class="com.hrc.myClass.MyselfClass"/>
<aop:config>
    
    <aop:aspect ref="myselfClass">
        
        <aop:pointcut id="pointcut" expression="execution(public * com.hrc.service..*(..))"/>
        
        <aop:before method="before" pointcut-ref="pointcut"/>
        <aop:after method="after" pointcut-ref="pointcut"/>
    aop:aspect>
aop:config>

SpringAOP 实现注解配置

// 使用注解方式实现AOP
@Aspect // 标注此类为一个切面
public class AnnotationPointcut {
    @Before("execution(public * com.hrc.service..*(..))")
    public void before() {
        System.out.println("【INFO】方法执行前");
    }
    @After("execution(public * com.hrc.service..*(..))")
    public void after() {
        System.out.println("【INFO】方法执行后");
    }
    // 在环绕增强中,可以给定一个参数,代表我们要获取的切入的点
    @Around("execution(public * com.hrc.service..*(..))")
    public void around(ProceedingJoinPoint pj) throws Throwable {
        System.out.println("【INFO】使用环绕之前");
        System.out.println("【INFO】获得签名:" + pj.getSignature());
        // 执行此方法
        Object proceed = pj.proceed();
        System.out.println("【INFO】获得执行对象:" + proceed);
        System.out.println("【INFO】使用环绕之后");
    }
}
<bean id="annotationPointcut" class="com.hrc.myClass.AnnotationPointcut"/>

<aop:aspectj-autoproxy/>

Spring整合MyBatis

实现步骤

  • 导入相关依赖
    • junit 单元测试
    • MyBatis
    • MySQL数据库
    • Spring相关
    • SpringAOP的相关依赖
    • MyBatis-Spring(一个新的依赖,可以和Spring完美整合)
  • 编写配置文件
  • 测试

相关依赖

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-webmvcartifactId>
    <version>5.2.7.RELEASEversion>
dependency>
<dependency>
    <groupId>junitgroupId>
    <artifactId>junitartifactId>
    <version>4.12version>
dependency>
<dependency>
    <groupId>org.aspectjgroupId>
    <artifactId>aspectjweaverartifactId>
    <version>1.9.5version>
dependency>
<dependency>
    <groupId>org.mybatisgroupId>
    <artifactId>mybatisartifactId>
    <version>3.5.5version>
dependency>
<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <version>5.1.47version>
dependency>

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-jdbcartifactId>
    <version>5.2.7.RELEASEversion>
dependency>
<dependency>
    <groupId>org.mybatisgroupId>
    <artifactId>mybatis-springartifactId>
    <version>2.0.5version>
dependency>

回顾MyBatis

  1. 编写实体类
  2. 编写核心配置文件
  3. 编写接口
  4. 编写mapper.xml
  5. 测试

MyBatis-Spring

  • 编写数据源配置

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8"/>
bean>
  • SqlSessionFactory

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
    <property name="mapperLocations" value="classpath*:com.hrc.mapper/UserMapper.xml"/>
bean>
  • SqlSessionTemplate

<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
    <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"/>
bean>
  • Mapper接口加实现类
import com.hrc.pojo.User;
import java.util.List;
public interface UserMapper {
    List<User> getUsers();
}
import com.hrc.mapper.UserMapper;
import com.hrc.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;
import java.util.List;
public class UserMapperImpl implements UserMapper {
    // 在以前都使用SqlSession来执行所有操作,现在只需要使用SqlSessionTemplate
    private SqlSessionTemplate sqlSession;
    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }
    @Override
    public List<User> getUsers() {
        return sqlSession.getMapper(UserMapper.class).getUsers();
    }
}
  • 测试
import com.hrc.mapper.UserMapper;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
    @Test
    public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper mapper = context.getBean("userMapper", UserMapper.class);
        mapper.getUsers().forEach(System.out::println);
    }
}

Spring-MyBatis还有一种整合方式,就是直接实现SqlSessionDaoSupport类


<bean id="mapper" class="com.hrc.mapper.impl.UserMapperImplement">
    <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
bean>
import com.hrc.mapper.UserMapper;
import com.hrc.pojo.User;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.List;
public class UserMapperImplement extends SqlSessionDaoSupport implements UserMapper {
    @Override
    public List<User> getUsers() {
        // 由于继承了SqlSessionDaoSupport类,可以直接使用getSqlSession方法得到进一步简化
        return getSqlSession().getMapper(UserMapper.class).getUsers();
    }
}

Spring中的声明式事务

回顾事务的基础知识

  • 要么同时成功,要么同时失败
  • 事务在项目开发中占据非常重要的位置,因为涉及到事务的一致性问题,所以必须认真对待
  • 确保完整性和一致性

事务的ACID原则

  • 原子性(Atomicity):确保一个业务当中的所有操作,要么同时成功,要么同时失败
  • 一致性(Consistency):事务的运行不改变数据当中的一致性,举个例子,对于银行转账来说,a用户有1000元,b用户有1000元,不管这个事务最后是成功还是失败,a+b的和始终都是2000
  • 隔离性(Isolation):多个事务可能操作同一个资源,防止资源损坏。事务与事务之间是处于隔离的状态,一个事务不应该影响其他事务的运行效果
  • 永久性(Durability):事务一旦提交,无论系统发生什么问题,都不会再被影响,被持久化的写到存储器中

Spring中的事务管理

  • 声明式事务:AOP

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
bean>


<tx:advice id="interceptor" transaction-manager="transactionManager">
    
    
    <tx:attributes>
        <tx:method name="addUser" propagation="REQUIRED" isolation="DEFAULT"/>
        <tx:method name="selectUsers"/>
        <tx:method name="delUser" propagation="REQUIRED"/>
        <tx:method name="*" propagation="REQUIRED"/> 
    tx:attributes>
tx:advice>
<aop:config>
    <aop:pointcut id="txPointcut" expression="execution(public * com.hrc.mapper..*.*(..))"/>
    <aop:advisor advice-ref="interceptor" pointcut-ref="txPointcut"/>
aop:config>
  • 编程式事务:需要在代码中进行事务的管理

为什么需要事务

  • 如果不配置事务,可能存在数据提交不一致的情况
  • 如果不在Spring中去配置事务,那么就需要在代码中手动配置事务
  • 事务在项目的开发中十分重要,涉及到数据的一致性和完整性

最后再多聊一嘴Spring中事务的传播属性

传播属性

刚刚在使用xml进行事务的织入时有一个标签叫做propagation,propagation在xml中可以进行事务的传播属性的处理配置,它主要有以下几种属性
(面试可能会问到,建议最好还是记一下)

  • REQUIRED:这个属性表示当前业务必须存在事务的处理,如果没有,就会自动创建一个新的事务(这个属性值在开发中属于常用,并且也是Spring默认处理的传播属性)
  • SUPPORTS:如果现在有事务,那么当前业务就直接使用事务进行处理,如果没有,就以非事务的方式运行
  • MANDATORY:如果当前开启了一个事务,就会以事务的方式运行,如果没有事务,就会抛出相应的异常
  • REQUIRES_NEW:这个属性总是会开启新的事务,如果在开启新事务之前已经有了一个事务,就会将这个事务挂起
  • NOT_SUPPORTED:总是以非事务的方式处理业务,如果当前有事务,就会将当前事务挂起
  • NEVER:总是以非事务的方式处理业务,如果当前有事务,则会抛出相应的异常
  • NESTED:如果当前有一个事务正在进行业务处理,那么这个属性值就会再次开启一个事务,内嵌进已经存在的事务之中,如果当前没有事务,则会以REQUIRED的方式进行处理

你可能感兴趣的:(狂神说Java,spring,java,aop,mybatis,ioc)