一-Spring基础(1)-配置-【JavaEE开发的颠覆者】

一、构建Spring项目

1.使用maven构建项目后，修改pom.xml文件，增加Spring的依赖，添加编译插件，将编译级别设置为1.7.

<!--增加Spring的依赖，添加编译插件，将编译级别设置为1.7.-->
<properties>
<java.version>1.5</java.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.1.6.RELEASE</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3.2</version>
<configuration>
<source>${java.version}</source>
<targer>${java.version}</targer>
</configuration>
</plugin>
</plugins>
</build>

二、Spring基础配置

1.Spring框架本身有四大原则

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

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

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

（4）使用AOP和模板（tempalte）减少模式化代码

2.依赖注入

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

声明Bean的注解：

@Component 组件，没有明确的角色

@Service 在业务逻辑层（service层）使用

@Repository 在数据访问层（dao层）使用

@Controller 在展现层（MVC->SpringMVC）使用

注入Bean的注解，易班情况下通用：

@Autowired Spring提供的注解

@Inject JSR-330提供的注解

@Resource JSR-250提供的注解

示例：

（1）编写功能类Bean，FunctionService

package zhao.spring.com.Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UseFunctionService {

@Autowired
FunctionService functionService;

public String useFunctionSayHelloWhat(String what){
return functionService.sayHelloWhat(what);
}
}
/**
* 使用@Service注解声明当前UseFunctionService类时Spring管理的一个Bean
*
* 使用@Autowired将FunctionService的实体Bean注入到UseFunctionService中
*/

（2）使用功能类Bean

package zhao.spring.com.Service;
import org.springframework.stereotype.Service;

@Service
public class FunctionService {
public String sayHelloWhat(String what){
return "Hello "+what+" !";
}
}
/**
* 使用Service注解声明当前FunctionService是Spring管理的一个Bean
*/

（3）配置类

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

@Configuration
@ComponentScan("zhao.spring.com.Service")
public class DiConfig {

}
/**
* 使用@Configuration声明当前类是一个配置类，之后用到
*
* 使用@ComponentScan自动扫描包名下所有使用@Service、@Component、@Repository和@Controller的类，并注册为Bean
*/

（4）运行

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import zhao.spring.com.Service.UseFunctionService;

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

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

System.out.println(useFunctionService.useFunctionSayHelloWhat("ZHAO"));
context.close();
}
}

/**
* 使用AnnotationConfigApplicationContext作为Spring容器，接受输入一个配置类作为参数
*
* 获得声明配置的UseFunctionService的Bean
*/

三、Java配置

Java配置是Spring 4.x推荐的配置方式，可以完全代替xml配置；Java配置也是Spring Boot推荐的配置方式。
Java配置是通过@Configuration和@Bean来实现的。
@Configuration声明当前类是一个配置类，相当于一个Spring配置的xml文件。
@Bean注解在方法上，声明当前方法的返回值为一个Bean。
这本书配置的原则：全局配置使用Java配置（如数据库相关配置、MVC相关配置），业务Bean的配置使用注解配置（@Service、@Component、@Repository、@Controller）

示例：

（1）功能类

/*
Java配置
*/
public class JavaPeizhiFunctionService {
public String sayHelloWhat(String what){
return "Hello "+what+" !";
}
}
/**
* 此处没有使用@Service声明Bean
*/

（2）使用功能类Bean

/*
Java配置
*/
public class JavaPeizhiUseFunctionService {
JavaPeizhiFunctionService javaPeizhiFunctionService;
public void setJavaPeizhiFunctionService(JavaPeizhiFunctionService javaPeizhiFunctionService) {
this.javaPeizhiFunctionService = javaPeizhiFunctionService;
}

public String SayHello(String what){
return javaPeizhiFunctionService.sayHelloWhat(what);
}
}
/**
* 此处没有使用@Service声明Bean
* 此处没有使用@Autowired注解注入Bean
*/

（3）配置类

/*
Java配置
*/
@Configuration
public class JavaPeizhiConfig {
@Bean
public JavaPeizhiFunctionService javaPeizhiFunctionService(){
return new JavaPeizhiFunctionService();
}

@Bean
public JavaPeizhiUseFunctionService javaPeizhiUseFunctionService(){
JavaPeizhiUseFunctionService javaPeizhiUseFunctionService=new JavaPeizhiUseFunctionService();
javaPeizhiUseFunctionService.setJavaPeizhiFunctionService(javaPeizhiFunctionService());
return javaPeizhiUseFunctionService;
}

//    @Bean
//    public JavaPeizhiUseFunctionService javaPeizhiUseFunctionService(JavaPeizhiFunctionService javaPeizhiFunctionService){
//        JavaPeizhiUseFunctionService javaPeizhiUseFunctionService=new JavaPeizhiUseFunctionService();
//        javaPeizhiUseFunctionService.setJavaPeizhiFunctionService(javaPeizhiFunctionService);
//        return javaPeizhiUseFunctionService;
//    }
}
/**
* 使用@Configuration注解表明当前类是一个配置类，这意味着这个类里可能有0个或者多个@Bean注解，此处没有使用包扫描，
*      是因为所有的Bean都在次类中定义了
* 使用@Bean注解声明当前方法JavaPeizhiFunctionService的返回值是一个Bean，Bean的名称是方法名。
*
* 注入JavaPeizhiFunctionService的Bean时候直接调用javaPeizhiFunctionService()
* 注释掉的是另一种注入方式，直接将JavaPeizhiFunctionService作为参数给javaPeizhiUseFunctionService()，在Spring容器中，
*      只要容器中存在某个Bean，就可以在另外一个Bean的声明方法的参数中传入
*/

（4）运行

public class JavaPeizhiMain {
public static void main(String[] args) {
AnnotationConfigApplicationContext context=
new AnnotationConfigApplicationContext(JavaPeizhiConfig.class);
JavaPeizhiUseFunctionService javaPeizhiUseFunctionService=
context.getBean(JavaPeizhiUseFunctionService.class);
System.out.println(javaPeizhiUseFunctionService.SayHello("ZHAO"));
context.close();
}
}