目录
1. 创建Spring 项目
1）?创建?个普通 Maven 项?。
2.）添加 Spring 框架?持（spring-context、spring-beans）。
3）?添加启动类。
1.1?创建?个 Maven 项?
?1.2 添加 Spring 框架支持
在项?的 pom.xml 中添加 Spring 框架的?持，xml 配置如下：
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
</dependencies>配置国内源
将下面两个框都要勾选上
?
?settings.xml 文件配置代码：
<mirrors>
<mirror>
<id>alimaven</id>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
<mirrorOf>central</mirrorOf>
</mirror>修改位置如下
?配置好之后，如果想下一次的项目也使用该国内源，则需下面的配置
?
?1.3 添加启动类
最后在创建好的项? java ?件夹下创建?个启动类，包含 main ?法即可
2. 存储 Bean 对象
存储 Bean 分为以下 3步：
1）存储 Bean 之前，先得有 Bean 才?，因此先要创建?个 Bean。
2)?配置?件 spring-config.xml
3）将创建的 Bean 注册到 Spring 容器中。
2.1?创建Bean?
Bean 就是 Java 语?中的?个普通对象，实现代码如下：
public class User {
public static void say(String name){
System.out.println("hello " + name);
}
}2.2?配置?spring-config.xml
在文件中添加以下代码
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>再将 User 对象注册到spring-config.xml 中就可以，具体操作是在 <beans> 中添加如下配置：
3. 获取并使用?Bean 对象
获取并使? Bean 对象，分为以下 3 步：
1. 得到 Spring 上下?对象，因为对象都交给 Spring 管理了，所以获取对象要从 Spring 中获取，那么就得先得到 Spring 的上下?。
2. 通过 Spring 上下?，获取某?个指定的 Bean 对象。
3. 使? Bean 对象。
3.1 创建Sprign 上下文
Spring 上下?对象可使? ApplicationContext，代码如下
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
}
除了 ApplicationContext 之外，我们还可以使? BeanFactory 来作为 Spring 的上下?，如下代码所示
// 1.得到 bean 工厂
BeanFactory factory = new XmlBeanFactory(
new ClassPathResource("spring-config.xml"));
// 2.获取 bean
User user = (User) factory.getBean("user");
// 3.使用 bean
user.say("黄小小");ApplicationContext 和 BeanFactory 效果是?样的，ApplicationContext 属于 BeanFactory 的?类， 它们的区别如下
1）继承关系和功能??来说：Spring 容器有两个顶级的接?：BeanFactory 和ApplicationContext。
其中 BeanFactory 提供了基础的访问容器的能?，? ApplicationContext 属于 BeanFactory 的?类，它除了继承了 BeanFactory 的所有功能之外，它还拥有独特的特性，还添加了对国际化?持、资源访问?持、以及事件传播等??的?持。
2）从性能??来说：ApplicationContext 是?次性加载并初始化所有的 Bean 对象，? BeanFactory是需要那个才去加载那个，因此更加轻量。
?3.2??获取指定的 Bean 对象
//2.根据上下文对象提供的方法获取到 bean
//User user = (User) context.getBean("user");//与spring-config.xml 中的id 一致
//User user = context.getBean(User.class);//不需要强转，但不建议使用
User user = context.getBean("user",User.class);//精准并不需要强转，推荐使用
?3.3 使用Bean
//3.使用
user.say("黄小小");总代码：
public class App {
public static void main(String[] args) {
//1.得到 spring 上下文对象
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
//2.根据上下文对象提供的方法获取到 bean
//User user = (User) context.getBean("user");//与spring-config.xml 中的id 一致
//User user = context.getBean(User.class);//不需要强转，但不建议使用
User user = context.getBean("user",User.class);//精准并不需要强转，推荐使用
//3.使用
user.say("黄小小");
}
}
4.总结
更简单的获取和存储对象
5.配置扫描路径
想要将对象成功的存储到 Spring 中，我们需要配置?下存储对象的扫描包路径，只有被配置的包下的所有类，添加了注解才能被正确的识别并保存到 Spring 中。
在 spring-config.xml 添加如下配置：
<?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:content="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<content:component-scan base-package="com.beans"></content:component-scan>
</beans>
6.添加注解存储 bean对象
想要将对象存储在 Spring 中，有两种注解类型可以实现：
1）? 类注解：@Controller、@Service、@Repository、@Component、@Configuration。2）? ?法注解：@Bean
6.1 @Controller（控制器存储）?
使? @Controller 存储 bean 的代码如下所示：
在要扫描的根路径（com.beans）下创建一个?UserController 类
import org.springframework.stereotype.Controller;
@Controller//将对象存储到Spring中
public class UserController {
public void sayHi() {
System.out.println("hello controller");
}
}
在main 方法中用读取对象的?式来读取上?的 UserController 对象，如下代码所示
public class App {
public static void main(String[] args) {
//1. 先得到上下文对象
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
//2.得到bean
UserController controller = context.getBean("userController",UserController.class);
//3.使用 bean
controller.sayHi();
}
}代码注入解释：
获取结果
?6.2 @Service （服务器存储）
使? @Service
存储 bean 的代码如下所示：
在要扫描的根路径（com.beans）下创建一个?UserService类
import org.springframework.stereotype.Service;
@Service
public class UserService {
public void sayHi() {
System.out.println("hello service");
}
}在main 方法中用读取对象的?式来读取上?的 UserService 对象，如下代码所示
public class App {
public static void main(String[] args) {
//1. 先得到上下文对象
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
//2.得到bean
UserService service = context.getBean("userService",UserService.class);
//3.使用 bean
service.sayHi();
}
}6.3 @Repository （仓库存储）
使? @Repository
存储 bean 的代码如下所示：
在要扫描的根路径（com.beans）下创建一个?UserRepository 类
import org.springframework.stereotype.Repository;
@Repository
public class UserRepository {
public void sayHi() {
System.out.println("hello repository");
}
}在main 方法中用读取对象的?式来读取上?的 UserController 对象，如下代码所示
public class App {
public static void main(String[] args) {
//1. 先得到上下文对象
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
//2.得到bean
UserRepository repository = context.getBean("userRepository",UserRepository.class);
//3.使用 bean
repository.sayHi();
}
}6.4 @Component （组件存储）
使用?@Component
存储 bean 的代码如下所示：
在要扫描的根路径（com.beans）下创建一个?UserComponent 类
import org.springframework.stereotype.Component;
@Component
public class UserComponent {
public void sayHi() {
System.out.println("hello component");
}
}在main 方法中用读取对象的?式来读取上?的 UserComponent 对象，如下代码所示
public class App {
public static void main(String[] args) {
//1. 先得到上下文对象
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
//2.得到bean
UserComponent component = context.getBean("userComponent",UserComponent.class);
//3.使用 bean
component.sayHi();
}
}6.5?@Configuration（配置存储）
使用?@Configuration 存储 bean 的代码如下所示：
在要扫描的根路径（com.beans）下创建一个?UserConfig 类
@Configuration
public class UserConfig {
public void sayHi() {
System.out.println("hello Configuration");
}
}在main 方法中用读取对象的?式来读取上?的 UserConfig 对象，如下代码所示
public class App {
public static void main(String[] args) {
//1. 先得到上下文对象
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
//2.得到bean
UserConfig config = context.getBean("userConfig",UserConfig.class);
//3.使用 bean
config.sayHi();
}
}?6.6 为什么需要五大注解
让代码可读性提高，能直观的判断当前类的用途
查看 @Controller / @Service / @Repository / @Configuration 等注解的源码发现，
这些注解??都有?个注解 @Component，说明它们本身就是属于 @Component 的“?类。
6.7 方法注解 @Bean
6.7.1 方法注解配合类注解使用
1)创建一个 bean
在要扫描的根路径（com.beans）下创建一个? UserBeans 类
在 Spring 框架的设计中，?法注解 @Bean 要配合类注解才能将对象正常的存储到 Spring 容器中
@Component
public class UserBeans {
@Bean
public User user1() {
User user = new User();
user.setId(1);
user.setName("黄小小");
return user;
}
}然后创建一个User对象
public class User {
private int id;
private String name;
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}在main 方法中用读取对象的?式来读取上?的 User?对象，如下代码所示
public class App {
public static void main(String[] args) {
//1. 先得到上下文对象
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
User user = context.getBean("user1",User.class);
System.out.println(user);
}
}
6.7.2 重命名Bean
当 User 类里面有多个对象时，可以通过设置 name 属性给 Bean 对象进?重命名操作，如下代码
@Component
public class UserBeans {
@Bean(name = "in")
public User user1() {
User user1 = new User();
user1.setId(1);
user1.setName("黄小小");
return user1;
}
@Bean(name = "to")
public User user2() {
User user2 = new User();
user2.setId(2);
user2.setName("杨通达");
return user2;
}
}?通过使用 Bean 里面的 name 就可以获取对象了
public class App {
public static void main(String[] args) {
//1. 先得到上下文对象
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
User user1 = context.getBean("in",User.class);
System.out.println(user1);
User user2 = context.getBean("to",User.class);
System.out.println(user2);
}
}
8.获取 Bean 对象
获取 bean 对象也叫做对象装配，是把对象取出来放到某个类中，有时候也叫对象注?。
类似于把 B 中的对象取出来放到 A 类当中
对象装配（对象注?）的实现?法以下
3
种：
1. 属性注?2. 构造?法注?3. Setter 注?
8.1 属性注入
属性注?是使? @Autowired 实现的。
下面将 UserService 类注?到 UserController2 类中。
UserService类
@Service
public class UserService {
public void sayHi() {
System.out.println("hello service");
}
}UserController2 类
@Controller
public class UserController2 {
//对象注入方式1：属性注入
@Autowired
private UserService userService;
public void sayHi() {
userService.sayHi();
}
}main方法
public class App2 {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
UserController2 userController2 =
context.getBean(UserController2.class);
userController2.sayHi();
}
}获取结果
?整个获取的调用链过程：
?8.2 构造方法注入
其中UserService类和上面属性注入的一样。
构造?法注?是在类的构造?法中实现注?，如下代码所示
@Controller
public class UserController3 {
private UserService userService;
//构造方法注入（官方推荐）
@Autowired
public UserController3(UserService userService) {
this.userService = userService;
}
/*
//当有多个构造方法时，上面的 @Autowired 不能省略
public UserController3(UserService userService, int num) {
this.userService = userService;
}*/
public void sayHi() {
userService.sayHi();
}
}8.3 Setter 注入
Setter 注?和属性的 Setter ?法实现类似，只不过在设置 set ?法的时候需要加上 @Autowired 注
解，如下代码所示：?
@Controller
public class UserController4 {
private UserService userService;
//Setter 注?
@Autowired
public void setUserService(UserService userService) {
this.userService = userService;
}
public void sayHi() {
userService.sayHi();
}
}8.4?三种注?优缺点分析
1）属性注?的优点是简洁，使??便；缺点是只能?于 IoC 容器，如果是? IoC 容器不可?，并且只有在使?的时候才会出现 NPE（空指针异常）。2）构造?法注?是 Spring 推荐的注??式，它的缺点是如果有多个注?会显得?较臃肿，但出现这种情况你应该考虑?下当前类是否符合程序的单?职责的设计模式了，它的优点是通?性，在使?之前?定能把保证注?的类不为空。3）Setter ?式是 Spring 前期版本推荐的注??式，但通?性不如构造?法，所有 Spring 现版本已经推荐使?构造?法注?的?式来进?类注?了
8.5 @Resource：另一种注入关键字
在进?类注?时，除了可以使? @Autowired 关键字之外，我们还可以使? @Resource 进?注?，如下代码所示
@Controller
public class UserController4 {
private UserService userService;
//Setter 注?
//@Autowired
@Resource
public void setUserService(UserService userService) {
this.userService = userService;
}
public void sayHi() {
userService.sayHi();
}
}
@Autowired 和 @Resource 的区别
1）出身不同：@Resource 来自于 JDK ，@Autowrired 是Spring 框架提供的2）用法不同：@Autowired 支持属性注入、构造方法注入和Setter 注入，而 @Resource 不支持构造方法注入。3）支持的参数不同：@Resource 支持更多的参数设置，比如 name 、type 设置，而@Autowired 只支持required 参数设置。