Spring Boot实战(1) Spring基础

1. Spring基础配置

Spring框架本身有四大原则：

1) 使用POJO进行轻量级和最小侵入式开发

2) 通过依赖注入和基于接口编程实现松耦合

3) 通过AOP和默认习惯进行声明式编程

4) 使用AOP和模板(template)减少模式化代码

所谓依赖注入指的是容器负责创建对象和维护对象间的依赖关系，而不是通过对象本身负责自己的创建和解决自己的依赖。依赖注入主要目的是为了解耦。

Spring Ioc容器(ApplicationContext)负责创建Bean，并通过容器将功能类Bean注入到你需要的Bean中。

声明Bean的注解：

a. @Component组件

b. @Service在业务逻辑层(Service层)使用

c. @Repository在数据访问层(dao层)使用

e. @Controller在展现层使用

注入Bean的注解，一般情况下是通用的：

a. @Autowired：Spring提供的注解

b. @Resourse： JSR-250提供的注解

c. @Inject： JSR-330提供的注解

示例：

1) 构件maven项目，其pom.xml配置文件如下：

 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 	<modelVersion>4.0.0</modelVersion>

 	<groupId>com.ws</groupId>
 	<artifactId>study1</artifactId>
 	<version>0.0.1-SNAPSHOT</version>
 	<packaging>jar</packaging>

 	<name>study1</name>
 	<url>http://maven.apache.org</url>

 	<properties>
 		<java.version>1.7</java.version>
 		<spring-framework.version>4.1.5.RELEASE</spring-framework.version>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 	</properties>

 	<dependencies>
 		<dependency>
 			<groupId>junit</groupId>
 			<artifactId>junit</artifactId>
 			<version>3.8.1</version>
 			<scope>test</scope>
 		</dependency>
 		<dependency>
 			<groupId>org.springframework</groupId>
 			<artifactId>spring-context</artifactId>
 			<version>${spring-framework.version}</version>
 		</dependency>
 	</dependencies>
 </project>
 

2) 编写功能类Bean

 package com.ws.study.one;

 import org.springframework.stereotype.Service;

 // @Service注解声明当前FunctionService类是Spring管理的一个Bean
 @Service
 public class FunctionService {
 	public String sayHello(String word){
 		return "Hello " + word + " !";
 	}
 }

3) 使用编写好的功能类Bean

 package com.ws.study.one;

 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;

 // @Service注解声明当前类是Spring管理的一个Bean
 @Service
 public class UseFunctionService {

 	// @Autowired实体将FunctionService的实体Bean注入到UseFunctionService中，
 	// 进而使UseFunctionService具备FunctionService的功能
 	@Autowired
 	FunctionService functionService;

 	public String sayHello(String word){
 		return functionService.sayHello(word);
 	}
 }
 

4) 配置类

 package com.ws.study.one;

 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.stereotype.Component;

 // @Component声明当前类是一个配置类
 @Component
 // 使用@ComponentScan，自动扫描包下所有使用@Service、@Component、@Repository和@Controller的类，并注册为Bean
 @ComponentScan("com.ws.study.one")
 public class DiConfig {

 }
 

5) 运行类

 package com.ws.study.one;

 import org.springframework.context.annotation.AnnotationConfigApplicationContext;

 public class Main {
 	public static void main(String[] args) {
 		// 使用AnnotationConfigApplicationContext作为Spring容器，接受输入一个配置类作为参数
 		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(DiConfig.class);

 		// 获取声明配置的UseFunctionService的Bean
 		UseFunctionService useFunctionService = context.getBean(UseFunctionService.class);

 		System.out.println(useFunctionService.sayHello("di"));

 		context.close();
 	}
 }
 

6) 运行结果

 五月 29, 2018 11:07:20 下午 org.springframework.context.annotation.AnnotationConfigApplicationContext prepareRefresh
 信息: Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@1fc0f2f: startup date [Tue May 29 23:07:20 CST 2018]; root of context hierarchy
 Hello di !
 五月 29, 2018 11:07:20 下午 org.springframework.context.annotation.AnnotationConfigApplicationContext doClose
 信息: Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@1fc0f2f: startup date [Tue May 29 23:07:20 CST 2018]; root of context hierarchy
 

2. Java配置

java配置可以完全替代xml配置，也是Spring Boot推荐的配置方式。java配置是通过@Configuration和@Bean来实现的。

a. @Configuration声明当前类是一个配置类，相当于一个Spring配置的xml文件

b. @Bean注解在方法上，声明当前方法的返回值是一个Bean

何时使用java配置或注解配置？原则：全局配置使用java配置(如数据库配置、MVC相关配置)，业务Bean的配置使用注解配置(@Service、@Component、@Repository、@Controller)

示例：

1) 编写功能类

 package com.ws.study.javaconfig;

 // 此处没有@Service声明的Bean
 public class FunctionService {
 	public String sayHello(String word){
 		return "Hello " + word + " !";
 	}
 }
 

2) 使用功能类

 package com.ws.study.javaconfig;

 //此处没有@Service声明的Bean
 public class UseFunctionService {
 	// 此处没有@Autowired声明的Bean
 	FunctionService functionService;

 	public void setFunctionService(FunctionService functionService) {
 		this.functionService = functionService;
 	}

 	public String sayHello(String word){
 		return functionService.sayHello(word);
 	}
 }
 

3) 配置类

 package com.ws.study.javaconfig;

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

 // 使用@Configuration注解声明当前类是一个配置类。意味着这个类中可能存在0个或多个@Bean注解
 // 此处没有使用包扫描，是因为所有的Bean都在此类中定义了
 @Configuration
 public class JavaConfig {

 	// 使用@Bean注解声明当前方法FunctionService的返回值是一个Bean，Bean的名称是方法名
 	@Bean
 	public FunctionService functionService(){
 		return new FunctionService();
 	}

 	@Bean
 	public UseFunctionService useFunctionService(){
 		UseFunctionService useFunctionService = new UseFunctionService();
 		// 注入FunctionService的Bean时候直接调用functionService()
 		useFunctionService.setFunctionService(functionService());
 		return useFunctionService;
 	}

 //	// 另外一种注解方式，直接将FunctionService作为参数给useFunctionService()
 //	// 在Spring容器中，只要容器中存在某个Bean，就可以在另外一个Bean的声明方法的参数中写入
 //	@Bean
 //	public UseFunctionService useFunctionService(FunctionService functionService){
 //		UseFunctionService useFunctionService = new UseFunctionService();
 //		useFunctionService.setFunctionService(functionService);
 //		return useFunctionService;
 //	}
 }
 

4) 运行类

 package com.ws.study.javaconfig;

 import org.springframework.context.annotation.AnnotationConfigApplicationContext;

 public class Main {
 	public static void main(String[] args) {
 		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(JavaConfig.class);

 		UseFunctionService useFunctionService = context.getBean(UseFunctionService.class);

 		System.out.println(useFunctionService.sayHello("java config"));

 		context.close();
 	}
 }
 

5) 运行结果

 五月 29, 2018 11:36:47 下午 org.springframework.context.annotation.AnnotationConfigApplicationContext prepareRefresh
 信息: Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@1fc0f2f: startup date [Tue May 29 23:36:47 CST 2018]; root of context hierarchy
 Hello java config !
 五月 29, 2018 11:36:47 下午 org.springframework.context.annotation.AnnotationConfigApplicationContext doClose
 信息: Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@1fc0f2f: startup date [Tue May 29 23:36:47 CST 2018]; root of context hierarchy
 

3. AOP

AOP为面向切面编程，切面编程是指在程序运行期间将某段代码，动态的切入到某个类的指定方法的指定位置。AOP存在的目的是为了解耦。AOP可以让一组类共享相同的行为。Spring支持AspectJ的注解式切面编程。

a. 使用@AspectJ声明是一个切面

b. 使用@After、@Before、@Around定义建言(advice)，可直接将拦截规则(切点)作为参数。为了使拦截规则(切点)复用，可使用@PointCut专门定义拦截规则，然后在@After、@Before、@Around的参数中调用。

c. 其中符合条件的每一个被拦截处为连接点(JoinPoint)

Spring本身在事务处理(@Transcational)和数据缓存(@Cacheable)上面都使用注解式拦截。

示例：

1) 添加spring aop支持及AspectJ依赖

 		<!-- spring aop支持 -->
 		<dependency>
 			<groupId>org.springframework</groupId>
 			<artifactId>spring-aop</artifactId>
 			<version>${spring-framework.version}</version>
 		</dependency>
 		<!-- aspectj支持 -->
 		<dependency>
 			<groupId>org.aspectj</groupId>
 			<artifactId>aspectjrt</artifactId>
 			<version>1.8.6</version>
 		</dependency>
 		<dependency>
 			<groupId>org.aspectj</groupId>
 			<artifactId>aspectjweaver</artifactId>
 			<version>1.8.5</version>
 		</dependency>

2) 编写拦截规则的注解

 package com.ws.study.aop;

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

 // 注解本身没有功能
 // 注解和XML都是元数据
 // 注解的功能来自用这个注解的地方
 @Target(ElementType.METHOD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Action {
 }
 

3) 编写使用注解的被拦截类

 package com.ws.study.aop;

 import org.springframework.stereotype.Service;

 @Service
 public class DemoAnnotationService {
 	@Action(name = "注解式拦截的add操作")
 	public void add(){}
 }
 

4) 编写使用方法规则被拦截类

 package com.ws.study.aop;

 import org.springframework.stereotype.Service;

 @Service
 public class DemoMethodService {
 	public void add(){}
 }
 

5) 编写切面

 package com.ws.study.aop;

 import java.lang.reflect.Method;

 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;

 // @Aspect注解声明一个切面
 @Aspect
 // @Component让此切面成为Spring容器管理的Bean
 @Component
 public class LogAspect {

 	// @Pointcut注解声明切点
 	@Pointcut("@annotation(com.ws.study.aop.Action)")
 	public void annotationPointCut(){};

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

 	// 通过@Before注解声明一个建言，此建言直接使用拦截规则作为参数
 	@Before("execution(* com.ws.study.aop.DemoMethodService.*(..))")
 	public void before(JoinPoint joinPoint){
 		MethodSignature signature = (MethodSignature)joinPoint.getSignature();
 		Method method = signature.getMethod();
 		System.out.println("方法规则式拦截： "+method.getName());
 	}
 }
 

6) 配置类

 package com.ws.study.aop;

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

 @Configuration
 @ComponentScan("com.ws.study.aop")
 // 使用@EnableAspectJAutoProxy注解开启Spring对AspectJ代理的支持
 @EnableAspectJAutoProxy
 public class AopConfig {

 }
 

7) 运行类

 package com.ws.study.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);
 		demoAnnotationService.add();

 		DemoMethodService demoMethodService = context.getBean(DemoMethodService.class);
 		demoMethodService.add();

 		context.close();
 	}

 }
 

8) 运行结果

 五月 30, 2018 10:06:14 下午 org.springframework.context.annotation.AnnotationConfigApplicationContext prepareRefresh
 信息: Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@1531931: startup date [Wed May 30 22:06:14 CST 2018]; root of context hierarchy
 注解式拦截：注解式拦截的add操作
 方法规则式拦截： add
 五月 30, 2018 10:12:09 下午 org.springframework.context.annotation.AnnotationConfigApplicationContext doClose
 信息: Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@1531931: startup date [Wed May 30 22:06:14 CST 2018]; root of context hierarchy