SpringBoot快速入门01- Spring 的 IOC/DI、AOP，

Servlet【理解为主】

web 服务器，就是一个运行 web 项目的容器

Tomcat

Apache

各大公司有自己做的

...

servlet 是运行在服务器上的程序，作用

接收请求

做出响应

演示

创建 web 项目图片

写 servlet 程序

servlet 是封装好的程序，所以导包

XML 复制代码

<!-- 引入servlet依赖 -->
<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>
  <version>3.1.0</version>
</dependency>
<!-- 引入jsp依赖 -->
<dependency>
  <groupId>javax.servlet.jsp</groupId>
  <artifactId>javax.servlet.jsp-api</artifactId>
  <version>2.3.1</version>
</dependency>

接收请求

做出响应

服务端一般是三层架构

控制层（servlet）

业务层（service）

持久层（dao）

部署到 tomcat

启动

前端

html,css

记住 web 开发流程 **[重点]**

记住项目结构 [重点]

记住 tomcat 端口，默认是 8080

SpringBoot

servlet 比较麻烦后来使用 ssm 框架

Spring , 容器，帮你管理整个的对象

SpringMVC, web 框架，封装了 servlet

Mybatis , 封装了 jdbc

一、引言 - SpringBoot 之前

1.1 初始化配置

为了使用 SSM 框架去开发，准备 SSM 框架的模板配置。

1.2 整合第三方框架

为了 Spring 整合第三方框架，单独的去编写 xml 文件。

1.3 后期维护

后期 SSM 项目后期 xml 文件特别多，维护 xml 文件的成本是很高的

1.4 部署工程

SSM 工程部署也是很麻烦，依赖第三方的容器

1.5 敏捷式开发

基于 Java 的 SSM 开发方式是很笨重，而现在的 python，php，NodeJS 的敏捷式开发已经盖过 Java 一头

二、SpringBoot 介绍

SpringBoot 是由 Pivotal 团队研发的，SpringBoot 并不是一门新技术，只是将之前常用的 Spring，SpringMVC，data-jpa 等常用的框架封装到了一起，帮助你隐藏这些框架的整合细节 ，实现敏捷开发。约定大于配置

SpringBoot 就是一个工具集。官网：https://spring.io/projects/spring-boot

SpringBoot 特点：

SpringBoot 项目不需要模板化的配置。

SpringBoot 中整合第三方框架时，只需要导入相应的 starter 依赖包，就自动整合了。

SpringBoot 默认只有一个.properties 或者.yml 的配置文件，不推荐使用 xml。

SpringBoot 工程在部署时，采用的是 jar 包的方式，内部自动依赖 Tomcat容器，提供了多环境的配置。

后期要学习的微服务框架 SpringCloud 需要建立在 SpringBoot 的基础上。

看完回答几个问题？

什么是框架？

没有框架，原始操作，一砖一砖的盖，麻烦，慢

框架，快速搭建主体，节省时间搞业务

java 常用框架有哪些？

ssm

ssm 分别是什么框架，干什么的？

SpringBoot 是干什么的？

和 SSM 什么关系？

SpringBoot 为什么好用？

三、SpringBoot 快速入门

3.1 快速构建 SpringBoot

3.1.1 选择构建项目的类型

注意：根据网络状况，可能会提示无法连接。如果不能连接，使用http://start.springboot.io(或者http://start.aliyun.com）

3.1.2 指定 SpringBoot 版本和需要的依赖

指定 SpringBoot 版本和需要的依赖

3.1.3 导入依赖

xml

XML 复制代码

<!-- 如果没有该依赖,就手动cv下方的依赖,到pom.xml -->  
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>

3.1.4 编写了 Controller

Controller 就是之前的 Servlet, 用于接收请求做出响应

如果使用的是start.aliyun.com创建的项目，它会自带一些测试接口在 demos 包下，直接删除它

创建一个 controller 包，单独写 controller 类

java

java 复制代码

@Controller   // 声明该类是控制层,就可以接收请求做出响应
public class TestController {
    @RequestMapping("/test") // 接收请求路径
    public String test(){
        return "ok.html"; // 请求转发,跳转页面
    }
    @RequestMapping("/user/login") // 接收请求路径
    public String test(){
        return "/ok.html"; // 请求转发,跳转页面
    }
}

3.1.5 编写页面

在 resources/static 下创建 ok.html 页面ps: 默认的固定格式，只能在 resources 下，且只能是 static

3.1.6 测试

springboot 自带 tomcat, 不需要我们管 web 服务器的事

springboot 框架让 web 开发回归到原始的 java 方式，以 main 运行启动

springboot 项目创建成功后，会自动创建一个有 main 方法的类，我们称为主类或者叫主启动类

主类 --> 点击启动项目

启动成功效果

|---|
| |

SpringBoot 项目启动成功后，不会主动打开浏览器，需要自己手动打开浏览器测试

补充：一些问题

pom.xml 依赖报红，即下载失败，重启 idea, 再次下载，主要原因网络。多试几次

图片就是清空缓存重启

第一次启动项目，一定点击主类，不要直接点右上角按钮

不要点击 idea 的 html 页面的右上角的浏览器标志

主类必须放在最外层，如下是不行的

主类一定要放在最外层，像下面这样

小技巧：改变项目结构展示效果

四、Spring

介绍...balabalaspring 的核心功能**++Spring 是一个容器，帮助管理 bean（豆）对象生命周期 (创建对象，使用对象，对象销毁等),++**

bean , 又称 javabean 就是对象

bean 翻译：豆子

java 翻译：爪哇岛，盛产咖啡豆

... 联想...

Spring 框架中主要的功能有

IOC

AOP

MVC ---> 将来会单独学，就是 springmvc 技术

Dao (JDBCTemplate) 等 ---> 不学，后期会学习 mybatis 操作数据库

所以现在学习 spring 的重点

管理对象技术: IOC

切面编程技术: AOP

4.1 IOC+DI [重点]

4.1.0 引言

使用 servlet 写的登录操作，都是自己手动 new 对象

认为上面这样直接 new 对象，不方便扩展，耦合度高....

Spring 框架的作用就是不需要我们像上面这样 new 对象

4.1.1 介绍

IOC 是 Spring 框架的核心功能之一，IOC(inversion of control)控制反转

控制: 控制创建对象的能力 (以前是自己需要什么对象，自己创建)

反转：原来创建对象是自己做，反转就是将创建对象的能力交给 SpringIOC (控制反转):

DI(dependency injection) 依赖注入，即属性赋值

Spring 的 ioc, 帮助我们++创建对象，是通过注解实现的++, 常用的创建对象的注解

@Controller 在控制层代码上使用

@Service 在业务层代码上使用

@Repository 在数据层代码上使用

@Component 在其他代码上使用

--> 以上四个注解都是创建对象用的，只不过建议是各层用对应的

属性赋值 DI (依赖注入的注解)

@Autowired

@Resource

4.1.2 演示 1

需求：项目中控制层 Controller 中需要使用到业务层 service 对象来处理业务

例如 AdminController 中需要创建 AdminService 对象使用，使用 IOC+DI 完成

AdminService 和 AdminServiceImpl

java 复制代码

public interface AdminService {
    void showIOC();
}
@Service // 创建对象,并放入到spring容器中
public class AdminServiceImpl implements AdminService {
    @Override
    public void showIOC() {
        System.out.println("------ 调用AdminServiceImpl --------");
        System.out.println("------ 调用AdminServiceImpl[结束] --------");
    }
}

AdminController

java 复制代码

@Controller //创建对象,并放入到spring容器中
public class AdminController {
    // 没有IOC时,是自己手动创建对象
    // private AdminService adminService = new AdminServiceImpl();
    // 有IOC时,是从spring容器中获取对象
    @Autowired
    private AdminService adminService;
    @RequestMapping("/show/ioc")
    public void showIOC(){
        System.out.println("------ 调用AdminController --------");
        // 调用业务层,这个对象是从spring容器中获取赋值给这个接口的,运行看子类
        adminService.showIOC();
        System.out.println("------ 调用AdminController[结束] --------");
    }
}

练习：在 AdminService 中使用 AdminDao 对象
创建 dao, 和 dao.impl 包以及 AdminDao,AdminDaoImpl

java 复制代码

public interface AdminDao {
    void showIOC();
}

java 复制代码

@Repository // 创建对象,放入到spring容器中
public class AdminDaoImpl implements AdminDao {
    @Override
    public void showIOC() {
        System.out.println("------ 调用AdminDaoImpl --------");
    }
}

业务层注入 Dao 层对象

java 复制代码

@Service // 创建对象,并放入到spring容器中
public class AdminServiceImpl implements AdminService {
    @Autowired
    private AdminDao adminDao;
    @Override
    public void showIOC() {
        System.out.println("------ 调用AdminServiceImpl --------");
        // 调用dao层
        adminDao.showIOC();
        System.out.println("------ 调用AdminServiceImpl[结束] --------");
    }
}

发请求测试

总结：

创建对象 spring 创建一个注解搞定控制反转 IOC

用对象的话用 @AutoWired 依赖注入 DI

4.1.3 演示 @Autowired 依赖注入 (属性赋值) 的原理

@Autowired 给属性赋值，是如何绑定属性赋值的？是按照类型注入的

但是如果 spring 容器中有多个同类型的对象时，@Autowired 注入就会失败

AdminService adminSerbvice = new AdServiceImp1 ();

AdminService adminSerbvice = new AdServiceImp2 ();

如果 spring 容器中有多个同类型的对象时，如何解决？

此时通过对象名来确定指定注入 (赋值) 哪个对象. @Qualifier("as2")对象名是什么？

默认通过 @Controller,@Service 等这些创建的对象，++对象名默认是类名首字母小写，++

也可以通过在 @Controller,@Service 等这些注解后设置对象名，例如 @Service ("as1")

扩展: @Autowired 和 @Resource 什么异同？

@Autowired是 Spring 专属，默认按类型匹配，需配合其他注解处理多 Bean 场景；

@Resource是 Java 标准注解，默认按名称匹配，自带属性更灵活、通用性更强。

4.1.4 演示 3

演示 @Component 注解创建对象

假如有个类 Admin, 现在需要该类对象，就可以在该类上加上 @Component 注解，并在其他地方使用 @Autowired 注入

4.2 AOP [熟悉]

说明

AOP: 面向切面编程

aspect 切面

OOP: 面向对象编程

即 AOP 就是一种特殊的编程写法，简单说就是抽取了一些代码，可以复用！

比如

事务管理

日志记录

权限控制

....

将这些重复性代码，抽取出来形成 ' 切面 ', 由这个切面帮这些 "目标类" 完成这些额外工作。背后的技术实现：代理模式.

编写

切面依赖

XML 复制代码

<!--aop依赖-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

创建切面类写切面 / 增强 / 通知方法指定目前类路径

java 复制代码

package com.qf.aspect;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
/**切面类
 */
@Component
@Aspect
public class MyAspect {
    /**
     * 前置通知: 在目标方法执行之前执行
     * 一般是权限校验
     *
     * @ Before就是前置通知,其中写的目标路径
     * 即对谁产生效果
     */
    @Before("execution(* com.qf.service.impl.*.*(..))")
    public void before() {
        System.out.println("---- 前置通知(权限校验) ----");
    }
    /**
     * 后置通知: 在目标方法执行之后执行
     * 一般是记录日志
     */
    @After("execution(* com.qf.service.impl.*.*(..))")
    public void after() {
        System.out.println("---- 后置通知(记录日志) ----");
    }
    /**
     * 环绕通知: 目标方法执行前后都执行
     * 一般是事务管理
     * ProceedingJoinPoint 目前方法对象
     */
    @Around("execution(* com.qf.service.impl.*.*(..))")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("---- 环绕通知(事务管理)前-开启事务 ----");
        try {
            // 执行目标方法
            joinPoint.proceed();
            System.out.println("---- 环绕通知(事务管理)后,提交事务 ----");
        } catch (Throwable throwable) {
            System.out.println("---- 环绕通知(事务管理)后,回滚事务 ----");
        }
    }
}

启动测试，访问任何一个请求都可以生效