Spring 环境

spring 与 maven

在maven官网中搜索spring，出现一系列的spring包供大家下载，其中 context、beans、core属于spring的核心包。其余的jar包根据你的需求来选择，相关驱动包的说明见下图。

spring 与 junit

通过maven中下载junit与spring-test的驱动包
需要注意的是你的spring-test的版本要与spring核心包的版本对应上，不然test可能会出现red bar。

Spring IOC

bean的创建主要有三种方式

• 在xml中定义bean，如：<bean id="xx" class="xx.xx.xx.class">

• 在类中使用类似于@Component、@Controller、@Service等注解来表示这是一个bean

• 在标注为@Configuration类的方法中使用@Bean标签（见代码），主要用于实例化第三方驱动包中的类以及配置类

程序一：@Configuration+@Bean

@Configuration
public class UserConfig {

    @Bean
    public Gril gril() {
        return new Gril();
    }

}

bean的加载主要有两种方式

• xml方式加载，在启动时候首先加载 application.xml文件，在xml文件中定义了扫描的包、以及启用注解

• JavaConfig的方式启动加载bean

程序二：JavaConfig方式启动

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);

bean的作用域

通过在bean的无参构造函数中我们可以打印一句话，会发现我们的构造函数只初始化了一次，这说明spring将我们的类变成了一个单实例的类。但是并不是所有的类都适合与成为单实例的类，如在我们的类中有局部变量存在的时候，单实例就可能造成资源的争抢。那么spring是怎么处理这种情况的呢？

spring将bean的作用域分为四种，通过@Scope来配置bean类的作用域

• 单例（singleton）：在整个应用中，只创建一个bean实例

• 原型（prototype）：每一次注入或者获取此类的时候都创建一个bean实例

• 会话（session）：在WEB应用中，为每个会话创建一个bean实例

• 请求（rquest）：在WEB应用中，为每个请求创建一个bean实例

第一种作用域在spring启动时，就会进行扫描和创建；第二种在需要时才会创建；第三、四种在有会话或者请求时才会创建。后续介绍Spring MVC的时候，在对第三、四种作用域进行详细说明

程序三：@Scope的用法

@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

注入

bean的创建好理解，但是我们能得最终目的是要在项目中将这些bean使用起来，这个时候就需要我们使用到Spring的注入功能了。Spring的注入使用@Autowired来完成。

可以直接在类中注入，也可以在构造函数中注入。注入得对象可以是实例化的类或者外部值。

程序四：类注入

@Autowired
private Gril gril;

程序五：构造函数注入

@Autowired
public User(Children children) {
    System.out.println("User类被加载: "+children.getName());
}

外部值的注入主要有三种方式

• Environment：此类是Spring为大家提供的获取配置文件值的工具类，配合@Configuration+@Bean来实现配置文件中的注入

程序六：Environment用法

@Configuration
@PropertySource("classpath:Config.properties")
public class ServerConfig {

    @Autowired
    Environment environment;

    @Bean
    public ServerConfigCls getServerConfigCls() {
        ServerConfigCls sc = new ServerConfigCls();
        sc.setPort(environment.getProperty("server.port"));
        return sc;
    }

}

class ServerConfigCls{
    private String port;
    public String getPort() {
        return port;
    }
    public void setPort(String port) {
        this.port = port;
    }
}

Spring AOP

AOP是Aspect Oriented Programming的缩写,意为:面向切面编程。由于Spring AOP利用Java的动态代理实现，因此，Spring AOP只支持方法级别的连接点。

切面

要想理解什么是面向切面编程就必须要明白什么是切面，对于Java来说，我们可以粗暴的把切面的理解为一个功能类，而所有被我们指定需要被切的类中的方法在执行的时候，都需要执行我们的这个功能类中相关方法。在上面已经说了Spring AOP是利用Java的动态代理实现的，那么就很好理解了。

程序一：模拟动态代理调用切面类

public void proxyMethod（）{
    try{
       执行前调用切面类相关方法   
       method.invoke........
       执行后调用切面类相关方法
    }catch(Exception e){
       异常时调用切面类相关方法  
    }
}

切点

大家都知道面是由点构成的，也就是说一个切面有多个切点。而切点决定了应该在什么地方使用切点的通知。

通知

通知定义了切面要干什么工作，以及在何时干什么工作。Spring AOP定义了下面5种通知类型

• 前置通知（Before）：目标方法被调用之前执行

• 后置通知（After）：目标方法完成之后执行，不关心输出

• 返回通知（After-returning）：目标方法成功执行之后执行

• 异常通知（After-throwing）：目标方法抛出异常后执行

• 环绕通知（Around）：在被通知的方法调用之前何调用之后执行自定义行为

连接点

连接点，是在应用执行过程中插入切面的一个点。一个连接点，总是代表一个方法的执行，而Target则表示执行的方法。通过JoinPoint可以获取到此连接点的详细信息，如：类名、方法名、参数等信息。

OK，有了通知，切点，我们就可以开始定义一个切面了，我们假设每一个实际方法被调用之前都需要执行一次start函数，完成后执行一次end函数，以此来监控一个方法的执行时间，从而找出最耗时的方法进行优化。

程序二：定义方法执行时间监控切面

@Aspect
@Component
public class PrintAspect {

    @Before("execution(* spring_aop.*.*(..))")
    public void before(JoinPoint joinpoint) {
        System.out.println("方法开始执行时间：" + joinpoint.getTarget().toString()+"."+joinpoint.getSignature().getName()+": "+System.currentTimeMillis());

        Object[] obj = joinpoint.getArgs();
        for(Object o : obj) {
            System.out.println("传递的参数为：" + o);
        }
    }
    @AfterReturning("execution(* spring_aop.*.*(..))")
    public void after(JoinPoint joinpoint) {
        System.out.println("方法执行结束时间：" + joinpoint.getTarget().toString()+"."+joinpoint.getSignature().getName()+": "+System.currentTimeMillis());
    }
}

仅仅是使用@Aspect是远远不够的，我们通过进入到@Aspec注解类未发现类似于@Component的注解，因此我们还需要将被@Aspect注解的类，注册为Spring bean。

execution 表达式

execution中还可以使用and（&&）、or（||）、not（!）、within、bean等组成更为复杂的切点表达式

环绕通知

程序一的确实现了开始时间何结束时间的监控，但是如果我们要计算出某一个方法的耗时，我们必须将开始时间存起来，这样就会出现线程安全的问题。因此在这个时候我们需要使用同时实现了前置通知何后置通知的环绕通知。

程序三：环绕通知

@Aspect
@Component
public class PrintAspect {

    @Around("execution(* spring_aop.*.*(..))")
    public void before(ProceedingJoinPoint joinpoint) {

        try {
            long start = System.currentTimeMillis();
            System.out.println("方法开始执行时间：" + joinpoint.getTarget().toString()+"."+joinpoint.getSignature().getName()+": "+start);

            joinpoint.proceed();// 执行实际调用的方法

            long end = System.currentTimeMillis();
            System.out.println("方法执行结束时间：" + joinpoint.getTarget().toString()+"."+joinpoint.getSignature().getName()+": "+end);

            System.out.println("此方法执行的时间为：" + (end - start));
        } catch (Throwable e) {
            e.printStackTrace();
        } 
    }
}

妙用@Pointcut注解

在程序一的代码中我们可以发现两个切点表达式一样，这可以是违反了java中的模块重用原则。因此我们需要使用@Pointcut来解决重复写相同的切点表达式的问题。

程序四：@Pointcut

@Aspect
@Component
public class PrintAspect {

    @Pointcut("execution(* spring_aop.*.*(..))")
    public void action() {};

    @Before("action()")
    public void before(JoinPoint joinpoint) {
        System.out.println("方法开始执行时间：" + joinpoint.getTarget().toString()+"."+joinpoint.getSignature().getName()+": "+System.currentTimeMillis());

        Object[] obj = joinpoint.getArgs();
        for(Object o : obj) {
            System.out.println("传递的参数为：" + o);
        }

    }

    @AfterReturning("action()")
    public void after(JoinPoint joinpoint) {
        System.out.println("方法执行结束时间：" + joinpoint.getTarget().toString()+"."+joinpoint.getSignature().getName()+": "+System.currentTimeMillis());
    }

}

代码中将切点表达式绑定在action方法上，其余的通知再绑定到action方法，从而来实现相同的切点表达式只需要书写一次即可，既提高开发效率又提高代码可读性。

后续将继续更新Spring实战系列。