Servlet项目开发和Spring Boot项目开发

Servlet项目开发和Spring Boot项目开发对比：
（一）创建项目。
Servlet项目开发：

（1） 创建maven项目； （2）去仓库查找servlet对应的版本和引用信息添加到pom.xml中； （3）点击maven导入框架按钮，创建Java源代码目录

Spring Boot项目开发：
直接创建springBoot项目并勾选添加项目依赖即可
（二）编写代码
Servlet项目开发：
（1）创建两个类（一个对应一个url：一个添加用户url/删除用户url）继承HttpServlet重写doGet/doPost方法
（2）使用request来获取参数
（3）业务逻辑
（4）设置返回的类型/设置编码格式/使用resp来返回结果
（三）运行项目
Servlet项目开发：
（1）安装插件smarttomcat
（2）配置idea中的smartomcat，运行的tomcat指向本地tomcat
（3）运行项目

Spring Boot项目开发：直接运行main方法即可
（四）发布项目
Servlet项目开发：
（1）maven打包，将打包好的war,jar上传到服务器
（2）在服务器上安装tomcat
（3）将war包放到webapps
（4）启动tomcat，运行项目
Spring Boot项目开发：
（1）maven打包，将打包好的war,jar上传到服务器
（2）使用java-jar xxx.jar直接运行

基本概念

• spring是包含了众多工具方法的Ioc容器

• Ioc：控制反转

• Ioc优点：实现代码的解耦；对象(Bean)生命周期交给Ioc框架来维护，程序员无需关注了。

• Spring Ioc容器最核心的功能：
  （1）将Bean（对象）存储在Spring(容器）中
  （2）将Bean（对象）从Spring（容器）中取出来

• DI：依赖注入。所谓依赖注入就是由Ioc容器在运行期间动态的将某种依赖关系注入到对象之中。

• 依赖注入和控制反转是从不同的角度的描述的同一件事情，就是指通过引入Ioc容器，利用依赖关系注入的方式实现对象之间的解耦。

• Ioc（控制反转）和DI（依赖注入）区别：IOC是一种思想，而DI是一种实现

Spring创建和使用

创建Spring项目

1.先创建一个maven项目

2.添加spring框架支持（spring-context和spring-beans）

<dependencies>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>5.2.3.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-beansartifactId>
<version>5.2.3.RELEASEversion>
dependency>
dependencies>
1
2
3
4
5
6
7
8
9
10
11
12

3.创建一个启动类并添加main
在创建好的项目Java文件夹下创建一个启动类，包含main方法即可：

将bean对象存储到容器（spring）中

1.在spring项目中添加配置文件（非第一次此步骤省略）

<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>
1
2
3
4
5
6
7

2.先创建一个bean对象

3.将bean通过配置文件注册到spring中

从Spring中将bean对象读取出来

1.先得到spring上下文对象
2.通过上下文对象提供的方法获取需要使用的bean对象
3.使用bean对象

方法一：

import com.beans.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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("userinfo");
//      3.使用
        user.sayHi("张三");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

方法二：

public class App {
    public static void main(String[] args) {
//        1.得到bean工厂
        BeanFactory factory=new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
//    2.获取bean
        User user=(User) factory.getBean("userinfo");
//        3.使用
        user.sayHi("李四");
    }
}
1
2
3
4
5
6
7
8
9
10

• ApplicationContext和BeanFactory区别：

相同点：都可以实现从容器中获取bean，都提供了getBean的方法
不同点：
（1）ApplicationContext属于BeanFactory的子类，BeanFactory只提供了基础访问bean的方法，而ApplicationContext除了拥有BeanFactory的所有功能之外，还提供了更多的方法实现，比如对国际化的支持，资源访问的支持，以及事件和传播等方面的支持。
（2）从性能方面来说二者是不同的，BeanFactory是按需加载Bean，ApplicationContext是饿汉方式，在创建时会将所有的Bean都加载起来，以备以后使用

• getBean更多用法：
  1.使用bean name获取bean
  
  2.根据bean type获取bean
  （写法简单，但容易出问题，当同一个类型被注入到spring中多次时候，就会报错）

Spring更简单的读取和存储对象

在Spring中想要更简单的存储和读取对象的核心是使用注解。

存储Bean对象

（一） 配置扫描路径
1.在pom.xml中添加：

```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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.在spring-config.xml添加如下配置：

<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>
1
2
3
4
5
6
7
8
9
10
11

（二）添加注解存储Bean对象
方法1.使用5大类注解实现：
@Controller(控制器）：表示的是业务逻辑层（前端参数校验）

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();

    }
}

1
2
3
4
5
6
7
8
9
10
11
12

@Service（服务）：服务层（数据的组装和接口调用）

 ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
  UserService service=context.getBean("userService",UserService.class);
        service.sayHi();
1
2
3

@Repoistory（仓库）：持久层（负责和数据库进行交互）
@Configuration（配置）：配置层
@Component（组件）

1. 需要5大类注解原因：让代码的可读性提高，让程序员能够直观的判断当前类的用途。
2. 5大类之间的关系：@Controller，@Service，@Repoistory，@Configuration都是基于@Component实现的，所以@Component可以认为是其他4个注解的父类。
   3.注意Bean的命名：
   通常我们bean使用的都是标准的大驼峰命名，而读取的时候首字母小写就可以获取到bean了
   

方法2.通过@Bean方法
类注解是添加到某个类上的，而方法注解是放到某个方法上的：
方法注解要配合类注解使用

@Component
public class UserBean {
    @Bean //只使用一个@Bean是无法将对象存储在容器中的
    public User user1(){
        User user=new User();
        user.setId(1);
        user.setName("张三");
        return user;


    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

• 重命名Bean
  通过设置name属性给Bean对象进行重命名操作

@Component
public class UserBean {
    @Bean(name={"user1"})//只使用一个@Bean是无法将对象存储在容器中的
    public User user1(){
        User user=new User();
        user.setId(1);
        user.setName("张三");
        return user;


    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

@Bean命名规则，当没有设置name属性时，那么bean默认的名称就是方法名，当设置了name属性之后，只能通过重命名name属性对应的值来获取，也就是说重命名之后，在使用方法名就获取不到bean对象了。

（二）获取Bean对象

• 对象注入（从容器中将对象读取出来）的实现方法有以下3种：
  1.属性注入

 ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
        UserController2 userController2=context.getBean(UserController2.class);
        userController2.sayHi();
1
2
3

@Controller
public class UserController2 {
//    对象注入方式1：属性注入
    @Autowired
    private UserService userService;
    public void sayHi(){
        userService.sayHi();
    }

}
1
2
3
4
5
6
7
8
9
10

2.构造方法注入

@Controller
public class UserController3 {
//    使用构造方法注入
    private UserService userService;
    @Autowired
    public UserController3(UserService userService){
        this.userService=userService;

    }
public void sayHi(){
        userService.sayHi();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

如果当前类中只存在一个构造方法，那么@Autowired注解可以省略

3.Setter注入

@Controller
public class UserContoller4 {
    private UserService userService;

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

    public void sayHi(){
        userService.sayHi();
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

属性注入和构造方法注入以及Setter注入的区别：
（1）属性注入特点写法简单，但是通用性不好，它只能运行在Ioc容器下。 （2）Setter注入通用性没有构造方法注入通用。
（3）构造方法注入通用性好，它能确保在使用注入对象之前，此注入对象一定初始化过了。（推荐的注入方式）

4. @Resource关键字注入
   @Resource支持属性注入和Setter注入，不支持构造方法注入

@Resource和@Autowired区别：
（1）出身不同：@Resource来自于JDK注解；@Autowired来自于Spring
（2）用法不同：@Autowired支持属性注入，构造方法注入和Setter注入，而@Resource不支持构造方法注入
（3）使用时设置的参数不同：@Resource支持更多的参数设置，如name，type设置，@Autowired只支持required参数设置

• @Bean将一个类型的对象注入多次的问题：
  解决方案：
  （1）精确的描述bean的名称

@Controller
public class UserController {
    @Autowired
    private User user;
    public void sayHi(){

        System.out.println("User->"+user);
    }
}
1
2
3
4
5
6
7
8
9

  //1.先得到上下文对象
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
        UserController controller=context.getBean(UserController.class);
        controller.sayHi();
1
2
3
4

（2）使用@Resource设置name的方式来重命名

 @Resource(name = "user1")
1

（3）使用@Autowired+@Qualifer来筛选bean对象

 @Autowired
 @Qualifier(value = "user1")
1
2

Bean作用域和生命周期

Bean作用域

• Bean的作用域是指Bean在Spring整个框架中的某种行为模式
• Bean的6种作用域：
  （1）singleton：单例作用域（默认）
  通常无状态的Bean使用该作用域。无状态表示Bean对象的属性状态不需要更新。
  （2）prototype:原型模式（多例模式）
  通常有状态的Bean使用该作用域。
  （3）request:请求作用域（Spring MVC）
  每次http请求会创建新的Bean实例
  （4）session：会话作用域（Spring MVC）
  （5）application：全局作用域（Spring MVC）
  （6）websocket：HTTP WebSocket作用域（Spring WebSocket）

单例作用域和全局作用域区别：
（1）singleton是Spring Core的作用域，application是Spring Web中的作用域。
（2）singleton作用于Ioc的容器，而application作用于servlet容器。

Bean生命周期

Bean的生命周期分为五部分：
1.实例化（给bean分配内存空间）
2.设置属性（对象注入）
3.初始化
（1）执行各种通知
（2）执行初始化的前置方法
（3）执行构造方法，两种方法：一种是执行@PostConstruct ，另一种实质性 init-method
（4）执行初始化后置方法
4.使用Bean
5.销毁Bean
（1）@PreDestory
（2）重写DisposableBean接口方法
（3）destroy-method