Spring的创建和使用

一.创建Spring

• 创建maven项目
• 添加 Spring 框架⽀持
• 添加启动类

1.添加启动类

  public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        User user = context.getBean("user",User.class);
        user.sayhi();
    }
}

2.添加spring框架依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>5.3.24</version>
</dependency>

3.将Bean注册到容器

bean就是java中的一个普通类.在Spring下添加配置文件spring-config.xml，添加到resource目录下
内容：

<! User类---->
public class User {
public String sayHi(String name) {
return name + " hello!";
}
}
<!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 http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
        <bean id="user" class="User"></bean>
</beans>

注册bean

<bean id="user" class="User"></bean>

4.创建context的上下文

// 1.得到 Spring 的上下⽂对象，创建的时候需要配置 Spring 配置信息
ApplicationContext context = new ClassPathXmlApplicationContext("spring-con
fig.xml");
//2.另一种创建方式
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("springconfig.xml"));

ApplicationContext 和 BeanFactory 效果是⼀样的，ApplicationContext 属于 BeanFactory 的⼦
类.

ApplicationContext VS BeanFactory

• 其中 BeanFactory 提供了基础的访问容器的能⼒，⽽ ApplicationContext
  属于 BeanFactory 的⼦类，它除了继承了 BeanFactory 的所有功能之外，它还拥有独特的特性，
  还添加了对国际化⽀持、资源访问⽀持、以及事件传播等⽅⾯的⽀持
• ApplicationContext是一次性加载并初始化所有对象,BeanFactory是用时加载。

5.获取bean对象

//第一种方式 通过类型
UserController user = context.getBean(UserController.class);
//第二种方式,通过名称+类型区bean
UserController user = context.getBean("user",Usercontroller.clss);

两者区别

• 当有一个类型被反复注册到spring-config.xml中时,只能根据名称来获取了

6.流程总结

流程图如下:

• 先创建Spring项目
• 创建Bean并且注册到Spring中(通过spring-config.xml)
• 创建启动类,获取Spring上下文
• 调用getBean()接口来获取bean
• 使用bean

二.更加的简便的读取和存储对象

1.存储bean对象

之前我们存储对象需要手动添加配置到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 http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
        <bean id="user" class="User"></bean>
        <bean id="user1" class="test.User"></bean>	
</beans>

其实我们有更加便捷的方法

1. 配置扫描路径
   • 在spring-config下添加如下配置
     2
2. 添加注解存储Bean对象

想要将对象存储在 Spring 中，有两种注解类型可以实现：
* 1.类注解: @Controller @Service @ Repository @Component @Configuration
* 2.方法注解 @Bean

代码如下:

@Controller // 将对象存储到 Spring 中  用剩下的四种也可以替换该注释效果一样
public class UserController {
 public void sayHi(String name) {
 System.out.println("Hi," + name);
 }
}

读取 bean 的代码：

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        User user = context.getBean("user",User.class);
        user.sayhi();
    }
}

那么为什么还需要这么多注释呢？

目的是为了当程序员看当注解后,可以更轻松的理解用途

• @Controller：表示业务逻辑层
• @Service：服务层
• @Repository: 持久层
• @Configuration：配置层

程序的⼯程分层，调⽤流程如下

类注解之间的关系

其实这些注解里面都有一个Component,可以理解为它们是Component的子类

1.Bean的命名规则

只有当类名前两个字母都是大写的时候,首字母不需要小写。其余情况都需要小写首字母

2.方法注解

方法注解需要搭配着五大类注解来使用

@Controller
public class User {
	public String name;
    @Bean
    public User sayhi()
    {
      	User u = new User();
      	u.name = "张三"';
      	return u;
    }
}

方法注解就是通过方法返回一个对象的,方法注解可以设置name属性：@Bean(name ={“123”,“sayhi”})

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        User user = context.getBean("123",User.class);

        System.out.println(user);
    }
}

3.属性注入

属性注入是通过@Autowired实现的,底层是通过反射实现

 @Autowired
    private Student student;

4.构造⽅法注⼊

private UserService userService;
 
@Autowired

 public UserController2(UserService userService) {
 this.userService = userService;
 }

5.Setter 注⼊

// 注⼊⽅法3：Setter注⼊

 private UserService userService;
 @Autowired

 public void setUserService(UserService userService) {
 this.userService = userService;
 }

三种注⼊优缺点分析

• 属性注入简洁,方便,缺点只能用于IoC容器,不能注入final修饰的成员,只有在引用的时候才会发现空指针异常
• 构造方法注入通用性强,在使用前一定保证注入的类不为空
• Setter ⽅式是 Spring 前期版本推荐的注⼊⽅式，但通⽤性不如构造⽅法，所有 Spring 现版本已
  经推荐使⽤构造⽅法注⼊的⽅式来进⾏类注⼊了。

6.@Resource另⼀种注⼊关键字

@Autowire和@Resource的区别

• @Autowire来自Spring,@Resource来jdk
• @Resource可以设置的参数比@Autowire多
• @Autowire可以适用于三种注入,而Resource不能用于构造函数注入

案例:
@Component

public class Users {
 @Bean

 public User user1() {
 User user = new User();
 user.setId(1);
 user.setName("Java");
 return user;
 }
 @Bean
 public User user2() {
 User user = new User();
 user.setId(2);
 user.setName("MySQL");
 return user;
 }
}

有相同类型的多种Bean

@Controller

public class UserController4 {
 // 注⼊
//@Autowire
//@Qualifier(value="user2")
 @Resource(name="user1")  
 private User user;
 public User getUser() {
 return user;
 }
}

这时候就需要使用@Resource中的name属性来区别相同类别的Bean中用哪一个了

三.总结

1. 将对象存储到 Spring 中：

   a. 使⽤类注解：@Controller、@Service、@Repository、@Configuration、@Component【它
   们之间的关系】

   b. 使⽤⽅法注解：@Bean【注意事项：必须配合类注解⼀起使⽤】

2. Bean 的命名规则：⾸字⺟和第⼆个字⺟都⾮⼤写，⾸字⺟⼩写来获取 Bean，如果⾸字⺟和第⼆个
   字⺟都是⼤写，那么直接使⽤原 Bean 名来获取 Bean。

3. 从 Spring 中获取对象：

   a. 属性注⼊

   b. Setter 注⼊

   c. 构造函数注⼊（推荐）

4. 注⼊的关键字有：

   a. @Autowired

   b. @Resource

5. @Autowired 和 @Resource 区别：出身不同； 使⽤时设置参数不同 @Resource ⽀持更多的参
   数，⽐如 name。

6. 解决同⼀类型多个 Bean 的报错：
   a. 使⽤ @Resource(name=“”)

   b. 使⽤ @Qualifier(“”)