Java方式配置Spring

概述

　　本文主要讲的是如何使用Java Bean来配置Spring，而不是用xml来配置Spring。

　　本文主要是代码，需要注意的都在注释里面。

　　代码打包下载地址(注：项目使用Maven构建)

---

 Java配置Spring

package com.wisely.highlight_spring4.ch1.javaconfig;

/**
 * 最终被调用的类
 */
public class FunctionService {
    public String sayHello(String word){
        return "Hello " + word +" !"; 
    }
}

package com.wisely.highlight_spring4.ch1.javaconfig;

/**
 * 调用类
 */
public class UseFunctionService {
    //这里也可以使用@Autowired将FunctionService的实体bean注入到UseFunctionService中,
    //让UseFunctionService具备将FunctionService的实体bean注入到UseFunctionService中的功能
    //@Autowired
    FunctionService functionService;
    
    public void setFunctionService(FunctionService functionService) {
        this.functionService = functionService;
    }
    
    public String SayHello(String word){
        return functionService.sayHello(word);
    }
}

package com.wisely.highlight_spring4.ch1.javaconfig;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 配置类，代替xml配置
 */
//声明当前类是一个配置类
@Configuration
//自动扫描包名下所有使用@Service/@Component/@Repository和@Controller的类,并注册为Bean
//@ComponentScan("com.wisely.highlight_spring4.ch1")
public class JavaConfig {
    /**
     * 声明当前方法的返回值是一个bean,bean的名称是方法名
     * @return bean
     */
    @Bean
    public FunctionService functionService(){
        return new FunctionService();
    }
    
    @Bean 
    public UseFunctionService useFunctionService(){
        UseFunctionService useFunctionService = new UseFunctionService();
        //注入FunctionService的时候直接调用functionService
        useFunctionService.setFunctionService(functionService()); //3
        return useFunctionService;
        
    }
    /**
     * 也可以将bean作为方法参数传入,spring会自动注入
     */
//    @Bean 
//    public UseFunctionService useFunctionService(FunctionService functionService){//4
//        UseFunctionService useFunctionService = new UseFunctionService();
//        useFunctionService.setFunctionService(functionService);
//        return useFunctionService;
//    }
}

package com.wisely.highlight_spring4.ch1.javaconfig;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * 程序入口
 */
public class Main {
    public static void main(String[] args) {
        //使用AnnotationConfigApplicationContext作为容器,
        //接受输入一个配置类作为参数
        AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(JavaConfig.class);
        //获得声明配置的UseFunctionService的Bean
        UseFunctionService useFunctionService = context.getBean(UseFunctionService.class);
        //调用输出方法
        System.out.println(useFunctionService.SayHello("java config"));
        context.close();
    }
}

　　最终效果如下所示

 Java配置AOP

package com.wisely.highlight_spring4.ch1.aop;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 拦截规则的注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Action {
    //注解参数
    String name();
}

package com.wisely.highlight_spring4.ch1.aop;

import org.springframework.stereotype.Service;

/**
 * 使用注解的被拦截类
 */
@Service
public class DemoAnnotationService {
    @Action(name="注解式拦截的add操作")
    public void add(){} 
}

package com.wisely.highlight_spring4.ch1.aop;

import org.springframework.stereotype.Service;

/**
 * 使用方法规则被拦截类
 */
@Service
public class DemoMethodService {
    public void add(){}
}

package com.wisely.highlight_spring4.ch1.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * 配置切面
 */
@Aspect //声明切面
@Component //让切面成为spring容器管理的bean
public class LogAspect {
    //声明切点,拦截Action
    @Pointcut("@annotation(com.wisely.highlight_spring4.ch1.aop.Action)")
    public void annotationPointCut() {
    }

    //声明建言,并使用@Pointcut定义的切点annotationPointCut()
    @After("annotationPointCut()")
    public void after(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        Action action = method.getAnnotation(Action.class);
        //通过反射获可得注解上的name属性,然后做日志记录相关的操作
        System.out.println("注解式拦截 " + action.name());
    }

    //声明建言,直接使用拦截规则作为参数
    @Before("execution(* com.wisely.highlight_spring4.ch1.aop.DemoMethodService.*(..))")
    public void before(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        System.out.println("方法规则式拦截," + method.getName());
    }
}

package com.wisely.highlight_spring4.ch1.aop;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * Spring配置类,因为程序中使用了诸如@Service之类的配置,所以这里不用写其他配置
 * 只需要使用@ComponentScan扫描一下就可以了
 */
@Configuration
//扫描注解,注册bean
@ComponentScan("com.wisely.highlight_spring4.ch1.aop")
//开启spring对AspectJ的支持
@EnableAspectJAutoProxy //1
public class AopConfig {

}

package com.wisely.highlight_spring4.ch1.aop;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * 程序入口
 */
public class Main {
    public static void main(String[] args) {
         AnnotationConfigApplicationContext context =
                    new AnnotationConfigApplicationContext(AopConfig.class);
         DemoAnnotationService demoAnnotationService = context.getBean(DemoAnnotationService.class);
         DemoMethodService demoMethodService = context.getBean(DemoMethodService.class);
         demoAnnotationService.add();
         demoMethodService.add();
         context.close();
    }
}

 　　最终效果如下所示