笔记05 SpringAOP

1.Spring 的依赖注入

1.1 什么是spring

它是一个轻量级和IOC(DI)和AOP的 容器框架
IOC：控制反转 现在创建bean的方式，是交给spring帮我们创建。(理解)
DI：依赖注入 spring它是容器框架，是一个bean(装对象的)容器框架，spring帮我创建好对象之后，在把我们创建好的对象 注入到相应的类里面 这个过程(理解)
1.2 spring的DI依赖注入

set方式注入
以前：
<bean id="userService" class="....UserServiceImpl">
	UserController{
	private UserService userService;
	void setUserService(UserService userService){
	this.userServicer = userService;
 	}
 }

构造器注入--掌握
index索引注入
<constructor-arg index="0" value="123"></constructor-arg>

name 参数名字注入
<constructor-arg name="id" value="456"></constructor-arg>

<constructor-arg type="java.lang.Long" value="111"></constructor-arg>

类里面属性注入–掌握

属性注入：  最常用就是基本类型和引用类型注入 --掌握
                <property name="id" value="111"></property>
                <property name="name" value="康康"></property>
    
                <property name="hellobean" ref="hb"></property>
                <property name="hellobean">
                       <bean class="xxxx"></bean>
                 </property>
              map list/set/array了解
              注入properties -- 掌握
                <property name="prop2">
                  <props>
                      <prop key="driverClassName">com.mysql.jdbc.Driver</prop>
                      <prop key="username">qiang强</prop>
                  </props>
              </property>

1.3 XML版本自动注入–了解

可以byName – 按照名称自动注入
或者byType注入 – 按照类型自动注入

1.4 XML版本注解注入–掌握

扫描包路径
<context:component-scan base-package="_03_annoxml.cn.itsource"></context:component-scan>

如果一个接口有两个实现情况下：

       方案一：一个接口有多个实现的情况下面 通过名字去区分
       方案二：通过Resource这个注解
       区别：@Autowired和@Qualifier 都是属于spring的注解 ，
          Resource使用jdk的注解 推荐使用Autowired和Qualifier，可以和spring进行无缝衔接
          autowired默认是根据类型匹配，如果类型匹配不上在根据名字匹配
          而Resource默认根据名字匹配，名字匹配不上就匹配类型

以后开发 --优先使用全注解方式(自己写的类) ，也要结合 xml配置

2 Spring里面AOP功能

2.1 什么是springAOP

AOP: 面向切面的编程

AOP使用场景：
事务管理
日志管理
性能控制

2.2aop的实现

aop底层使用代理模式实现
jdk代理模式 --有接口情况下
cglib动态代理 --没有接口情况下

2.3 springaop配置方式

xml版本的配置

<context:component-scan base-package="_04_aopxml"></context:component-scan>
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* _04_aopxml.I*Service.*(..))"></aop:pointcut>
        <!--配置通知-->
        <aop:aspect ref="txManager">
            <!-- 前置通知-->
            <!--<aop:before method="begin" pointcut-ref="pointcut"></aop:before>
            &lt;!&ndash; 后置通知&ndash;&gt;
            <aop:after-returning method="commit" pointcut-ref="pointcut"></aop:after-returning>
            &lt;!&ndash; 最终通知&ndash;&gt;
            <aop:after method="close" pointcut-ref="pointcut"></aop:after>
            &lt;!&ndash; 异常通知&ndash;&gt;
            <aop:after-throwing method="rollback" throwing="e" pointcut-ref="pointcut"></aop:after-throwing>-->
            <!-- 环绕通知-->
            <aop:around method="around" pointcut-ref="pointcut"></aop:around>
        </aop:aspect>
    </aop:config>
    <bean id="txManager" class="_04_aopxml.TxManager"></bean>

注解版本配置

@Component
@Aspect
public class TxManager {
@Pointcut("execution(* _05_aopanno.I*Service.*(..))")
public void pointcut(){}
 //<aop:before method="begin" pointcut-ref="pointcut"></aop:before>
 //@Before("pointcut()")
public void begin(){
 	System.out.println("开启事务");
}
  //  @After("pointcut()")
public void commit(){
System.out.println("提交事务");
}
//@AfterReturning("pointcut()")
public void close(){
System.out.println("关闭");
}
//所有的异常的父类
// @AfterThrowing(value = "pointcut()",throwing = "e")
public void rollback(Throwable e){
System.out.println("回滚事务"+e.getMessage());
//环绕通知
@Around("pointcut()")
public void around(ProceedingJoinPoint joinPoint){
 try {
 begin();
 //调用方法
 joinPoint.proceed();
 commit();
 } catch (Throwable throwable) {
  throwable.printStackTrace();
  }finally{
  close();
  	}
    }
}

3 Bean的创建方式

以前模式：通过new 对象方式创建
spring方式 ：spring帮我们创建bean 。–创建bean的方式

3.1 Bean创建方式一

通过无参数的构造方法来创建bean --最常用方式
配置

<bean id="mybean" class="_06_bean.Mybean"></bean>

3.2 Bean创建方式二

FactoryBean

public class MybeanFactoryBean implements FactoryBean<Mybean> {
	//返回对象
	public Mybean getObject() throws Exception {
		return new Mybean("xxx", "18");
	}
	public Class<?> getObjectType() {
		return Mybean.class;
	}
	//是否单例
	public boolean isSingleton() {
		return true;
		 }
	}

## 3.3 Bean创建方式三
通过类里面定义静态方法 来获取bean

	public class MybeanFactory {
	   	 public static Mybean getBean(){
	   		 return new Mybean();
	   	}
	}

3.4 Bean创建方式四

public class MybeanFactory1 {
	 //普通方式
	 public  Mybean getBean1(){
	 	return new Mybean();
	 	}
	 }

<bean class="_06_bean.MybeanFactory1" id="mybeanFactory1"></bean>
    <bean factory-bean="mybeanFactory1" factory-method="getBean1"></bean>