spring IOC 和AOP 方面

spring 的2大核心 是Ioc 和 aop

 spring的依赖注入：在程序运行期间，由外部容器动态的将依赖对象注入到组件中

 IOC:

实例化spring容器的二种方法

第一种：在类路径下寻找配置文件来实例化容器（实际开发中使用此方法）

ApplicationContext ctx= new ClassPathXmlApplicationContext(new String [] {"beans.xml"})

spring的配置文件可以有多个，所有可以用一个string数组来接收

第二种：在文件路径下寻找配置文件来实例化容器

ApplicationContext ctx= new FileSystemApplicationContext(new String [] {"bean.xml"})

spring获取bean

ApplicationContext ctx= new ClassPathXmlApplicationContext("beans.xml")

PersonService(接口) personService=（PersonService）ctx.getBean(personService);

 

Spring中ClassPathXmlApplication与FileSystemXmlApplicationContext的区别 参看：https://www.cnblogs.com/ninth/p/6841608.html

 

spring的依赖注入三种方式
第一种：构造器注入（最常用）
第二种：使用属性的setter方法注入
第三种：使用Field注入（采用注解方式）
1.构造器注入：

 <bean id="people" class="">

　　<construtor-arg index="0" type="java.lang.string" ref="axe" /> 　　//index表示构造器参数第几个，type表示参数的类型，ref表示引用类型
</bean> <bean id="axe" class=""/>

 2.setter 注入：

 <bean id="people" class=""> 　　

　　<property name="name" value="jaryle" /> //属性setter注入
</bean> <bean id="axe" class=""/>

 2.1 spring的依赖注入装配集合类型

　　set集合的注入 Set set= new HashSet();
<bean id="personService" class="com.jary.service.impl.PersonServiceBean" />
　　<property name="sets" >
　　<set>
　　<value> 第一个</value>
　　<value>第二个</value>
　　<value> 第三个</value>
　　</set>
　　</property>
</bean>
List集合的方式 List list = new ArraryList();
<bean id="personService" class="com.jary.service.impl.PersonServiceBean" />
　 <property name="lists" >
<list>
<value> 第一个</value>
<value>第二个</value>
<value> 第三个</value>
</list>
　　</property>
</bean>

 Map集合的方式Map map=new HashMap();

<bean id="personService" class="com.jary.service.impl.PersonServiceBean" />
<property name="maps" >
<map>
<entry key="key1" value="value1" />
<entry key="key2" value="value2" />
<entry key="key3" value="value3" />
</map>
</property>
</bean>

3. 注解的方式
　　使用前提是标注在字段和setter方法上

　　　需要在spring配置文件beans.xml加入注解的一些约束文件和配置注解的打开

　　<context:annocation-config /> //配置注解的打开（<context:component-scan base-package="com.*.*"/> 方式可替换该注解 ）
@Autowired和@Resource注解进行装配，二者的区别是@Autowired默认按类型装配，@Resource默认是按照名称装配，当找不到与名称匹配的bean就会按照类型装配。

   注意：建议使用@Resource进行装配，它是javaee中的包，而@Autowired是spring提供的注解包，扩展性没有前者好

    @Autowired默认情况下要求依赖对象必须存在，如果允许null值，可以设置它的required属性为false，如果想使用按照名称装配，可以结合@Qualifier注解一起使用，如下：

    @Autowired @Qualifier("personDaoBean")

    private PersonDao personDao;

    @Resource注解和@Autowired一样，亦可以标注在字段和setter方法上，但是它默认按照名称装配，名称可以通过它的name属性来指定，

 @Service("")  //注明类的名字
  public class MyServiceImpl
  {
    @Autowired       //注入Dao层，利用注解ppDao，必须在注入的类声明一致
    private PeopleDao ppDao;

  }

项目中，通常会有上百个组件

   显然会增加配置文件的体积，查找和维护起来不太方便，所以才引入在类路径下寻找标注了@Component（泛指组件，当组件不好归类时，使用此组件）、@Service(标注业务层相当于mvc中model)、    @Controller（标注控制层组件相当于struts2中action）、@Repository（标注数据访问组件即dao组件）注解的类，并把它们纳入spring容器中管理，我们只需要在beans.xml配置中打开自动扫描<!--哪些包利用注解-->

 <context:component-scan base-package="">

　　　　<context:include-filter type="regex" expression=""/> //根据需要配置

　　　　<context:exclude-filter type="regex" expression=""/>

</context:component-scan>

　　

常用注解：
@Component 指定名称的对象 
@Service 服务层的组件 
@Repository 数据层Dao的组件 
@Controller 控制层的组件 
@Autowired 注入属性，会从容器中自动查找对象并注入到@Autowired对象上面 
@Scope 指定作用域 
@Resource 在setter 方法上面定义 
@PostConstuct 即定义init-method 
@PreDestroy 即定义destroy-method 
@Lazy 
@DependsOn({“”,”“})

bean实现ApplicationContextAware，回调机制获取容器，自动注入spring容器
bean的作用域 
singleton、protoType、request、session、global session

AOP:
spring AOP技术（Proxy代理对象）
spring中的AOP面向切面编程(重点掌握)
首先了解一下AOP中的概念
Aspect(切面)：横切性关注点的抽象即为切面，它与类相似，只是二者的关注点不一样，类是对物体特征的抽象，而切面是横切性关注点的抽象
joinpoint(连接点)：那些被拦截到的点，在spring中这些点指的是方法，因为spring只支持方法类型的连接点，实际上，joinpoint还可以是field和类构造器
Pointcut(切入点)：对那些joinpoint进行拦截的定义
Advice(通知)：拦截到joinpoint之后所要做的事情就是通知，通知分为前置通知，后置通知，异常通知，最终通知，环绕通知。
Target(目标对象)：代理的目标对象
Weave(织入)：指将aspect应用到target对象并导致proxy对象创建的过程即是织入。
Introduction(引入)：在不修改类代码的前提下，Introduction可以在运行期为类动态的添加一些方法和field。

24. AOP通知

通知是个在方法执行前后要做的动作，实际上是程序执行时要通过SpringAOP框架触发的代码

Spring切面可以应用五种类型的通知：

before：前置通知，在一个方法执行前被调用。@Before

after: 在方法执行之后调用的通知，无论方法执行是否成功。@After

after-returning: 仅当方法成功完成后执行的通知。@AfterReturning

after-throwing: 在方法抛出异常退出时执行的通知。@AfterThrowing

around: 在方法执行之前和之后调用的通知。@Around

 

通过例子理解aop的Advice(通知)

　　基于xml

 

public interface Calculation {

    public int add(int x, int y);

    public int sub(int x, int y);

    public int mul(int x, int y);

    public int dev(int x, int y);
}

public class CalculationImpl implements Calculation {

    @Override
    public int add(int x, int y) {
        int result = x + y;
        System.out.println("executeing ...");
        return result;
    }

    @Override
    public int sub(int x, int y) {
        int result = x - y;
        return result;
    }

    @Override
    public int mul(int x, int y) {
        int result = x * y;
        return result;
    }

    @Override
    public int dev(int x, int y) {
        int result = x / y;
        System.out.println("executeing ...");
        return result;
    }

}

public class CalculationAspect {

    public void afterReturnMethod(JoinPoint joinPoint, Object ret) {
        String name = joinPoint.getSignature().getName();
        List<Object> list = Arrays.asList(joinPoint.getArgs());
        System.out.println("@AfterReturning ... ,method=" + name + ", args = "
                + list + ", return = " + ret);
    }

    public Object aroundMethod(ProceedingJoinPoint pjd) {
        String name = pjd.getSignature().getName();
        List<Object> list = Arrays.asList(pjd.getArgs());
        Object obj = null;

        System.out.println("前置通知 ... ,method=" + name + ", args = "
                + list);
        try {
            obj = pjd.proceed();
            System.out.println("返回通知 ... ,method=" + name + ", args = "
                    + list);
        } catch (Throwable e) {
            System.out.println("异常通知 ... , exception = " + e);
            e.printStackTrace();
        }
        System.out.println("后置通知 ... ,method=" + name + ", args = "
                + list);
        return obj;
    } 
}

第一个切入方法，我们其中有后置返回通知、环绕通知两个方法。

public class ValidateAspect {

    public void validate(){
        System.out.println("验证方法 com.gp.spring.aop.impl.ValidateAspect");
    }
}

第二个切入方法。

public class ValidateAspect {

    public void validate(){
        System.out.println("验证方法 com.gp.spring.aop.impl.ValidateAspect");
    }
}

<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:cache="http://www.springframework.org/schema/cache"
    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-4.1.xsd
        http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-4.1.xsd">

    <bean id="calculationImpl" class="com.gp.spring.aop.impl.xml.CalculationImpl"></bean>

    <bean id="calculationAspect" class="com.gp.spring.aop.impl.xml.CalculationAspect"></bean>

    <bean id="validateAspect" class="com.gp.spring.aop.impl.xml.ValidateAspect"></bean>

    <aop:config>
        <aop:pointcut
            expression="execution(public int com.gp.spring.aop.impl.xml.Calculation.*(int, int))"
            id="pointcut" />

        <aop:aspect ref="calculationAspect" order="1">
            <aop:after-returning method="afterReturnMethod"
                pointcut-ref="pointcut" returning="ret" />
            <aop:around method="aroundMethod" pointcut-ref="pointcut" />
        </aop:aspect>

        <aop:aspect ref="validateAspect" order="2">
            <aop:before method="validate" pointcut-ref="pointcut" />
        </aop:aspect>

    </aop:config>
</beans>

 

执行测试方法

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext-xml.xml");
        Calculation calculation = (Calculation)context.getBean("calculationImpl");
        int result = calculation.add(1, 3);
        System.out.println(result);
    }
输出结果

xml配置方式参照了：https://blog.csdn.net/gaopeng0071/article/details/47148239

注解方式配置通知方式
　　以AfterReturnig 为例子
　　

// 定义一个切面
@Aspect
public class LogAspect
{
    // 匹配com.owenapp.service.impl包下所有类的、
    // 所有方法的执行作为切入点
    @AfterReturning(returning="rvt"
        , pointcut="execution(* com.owen.app.service.impl.*.*(..))")
    // 声明rvt时指定的类型会限制目标方法必须返回指定类型的值或没有返回值
    // 此处将rvt的类型声明为Object，意味着对目标方法的返回值不加限制
    public void log(Object rvt)
    {
        System.out.println("获取目标方法返回值:" + rvt);
        System.out.println("模拟记录日志功能...");
    }
}
ServiceA {

     void methodA() {
         ServiceB.methodB();
     }

}

ServiceB {

     void methodB() {
     }

}
<?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-2.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
    <!-- configure transaction -->

    <tx:advice id="defaultTxAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="get*" read-only="true" />
            <tx:method name="query*" read-only="true" />
            <tx:method name="find*" read-only="true" />
            <tx:method name="*" propagation="REQUIRED" rollback-for="java.lang.Exception" />
        </tx:attributes>
    </tx:advice>

    <tx:advice id="logTxAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="get*" read-only="true" />
            <tx:method name="query*" read-only="true" />
            <tx:method name="find*" read-only="true" />
            <tx:method name="*" propagation="REQUIRES_NEW"
                rollback-for="java.lang.Exception" />
        </tx:attributes>
    </tx:advice>

    <aop:config>
          //切点
        <aop:pointcut id="defaultOperation"
            expression="@within(com.homent.util.DefaultTransaction)" />
        <aop:pointcut id="logServiceOperation"
            expression="execution(* com.homent.service.LogService.*(..))" />
              //定义通知器 在切点上开事务(advisor 通知器)
        <aop:advisor advice-ref="defaultTxAdvice" pointcut-ref="defaultOperation" />
        <aop:advisor advice-ref="logTxAdvice" pointcut-ref="logServiceOperation" />
    </aop:config>
</beans>