JavaWeb

前言

学到后面，会发现前面的一些东西已经后不上了。

旧

新

前后端交互

流程：

1.首先我们需要通过浏览器访问发布到前端服务器中的前端程序，这时候前端程序会将前端代码返回给浏览器。

2.浏览器得到前端代码，此时浏览器会将前端代码进行解析，然后展示到浏览器的窗口中，这时候我们就看到了网站的页面。

3.但是此时这个页面是没有数据的，因为数据在我们的数据库中，所以我们浏览器需要根据前端代码中指定的后台服务器的地址 向 我们的后台服务器（内部有java程序）发起请求，后台服务器再去从数据库中获取数据，然后返回给浏览器。

4.浏览器拿到后台返回的数据后，然后将数据展示在前端资源也就是网页上，然后我们就看到了如下图所示的完整的内容

前端

./ : 当前目录 , ./ 可以省略的

 ../: 上一级目录

HTML

 文档查阅地址：

w3school 在线教程 

菜鸟教程 - 学的不仅是技术，更是梦想！ (runoob.com)

CSS

引入样式

选择器

链接标签

常用设置

 

 JS

引入方式：内部脚本  外部脚本

三种输出语句：window.alert()  document.write()  console.log()

变量：var let const

数据类型:number string boolen null undefined

其他类型转换为Boolean：除0和NaN其他数字类型都转为true

===：不光比较值，还要比较类型，如果类型不一致，直接返回false  

函数定义的两种方式

    //定义函数-1
    // function add(a,b){
    //    return  a + b;
    // }

    //定义函数-2
    var add = function(a,b){
        return  a + b;
    }

数组可变，类型可变

BOM对象：Window Location 浏览器对象模型

DOM对象：JavaScript中将html的每一个标签都封装成一个对象  文档对象模型

Array对象：forEach push sploce

String对象

JSON对象：key必须使用引号并且是双引号标记，value可以是任意数据类型

常见事件：

Vue

概况

MVVM：Model-View-ViewModel

• Model: 数据模型，特指前端中通过请求从后台获取的数据

• View: 视图，用于展示数据的页面，可以理解成我们的html+css搭建的页面，但是没有数据

• ViewModel: 数据绑定到视图，负责将数据（Model）通过JavaScript的DOM技术，将数据展示到视图（View）上

ElementUI框架：替代HTML+CSS来更加方便的搭建View

vue框架：替代JavaScript的DOM操作

Model：可以通过Ajax来发起请求从后台获取

//引入
<script src="js/vue.js"></script>

//定义
<script>
    //定义Vue对象
    new Vue({
        el: "#app", //vue接管区域
        data:{
            message: "Hello Vue"
        }
    })
</script>

Vue指令

生命周期

菜鸟编程在Vue3组合式API

生命周期方法也被称为钩子方法

掌握一个：mounted   以后我们一般用于页面初始化自动的ajax请求后台数据

mounted () {
    //发送异步请求,加载数据
    axios.get("http://yapi.smart-xwork.cn/mock/169327/emp/list").then(result => {
        this.emps = result.data.data;
    })
}

Vue-cli功能

• 统一的目录结构

• 本地调试

• 热部署

• 单元测试

• 集成打包上线

note：需要先安装NodeJS，然后才能安装Vue-cli

创建vue项目

通过命令先进入到图形化界面，然后再进行vue工程的创建

vue ui

按照如下步骤进行：

文件目录不要有中文、括号

新建文件夹vue->管理员cmd打开当前目录->vue ui->按需选择（看md文档）

运行VUE：双击打开package.json文件，然后点击资源管理器处的3个小点，勾选npm脚本选项，选择第一个server

若端口号被占用，修改端口号：

App.vue,注意的是.vue结尾的都是vue组件。而vue的组件文件包含3个部分：

• template: 模板部分，主要是HTML代码，用来展示页面主体结构的

• script: js代码区域，主要是通过js代码来控制模板的数据来源和行为的

• style: css样式部分，主要通过css样式控制模板的页面效果得

vue组件库ElemenUI

官网：组件 | Element

导入不了可能式nodejs权限不够，百度搜索修改nodejs权限

熟练掌握CV

按钮、表格、分页、对话框、表单

路由

步骤

1.在src/router/index.js文件中定义路由表

2.main.js中，我们已经引入了router功能

3.修改2个页面（EmpView.vue和DeptView.vue）我们左侧栏的2个按钮为router-link

4.在App.vue中定义route-view

Ajax

 Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）

作用：

• 与服务器进行数据交换：通过Ajax可以给服务器发送请求，并获取服务器响应的数据。

• 异步交互：可以在不重新加载整个页面的情况下，与服务器交换数据并更新部分网页的技术

Vue 版本推荐使用 axios 来完成 ajax 请求(菜鸟文档在Vue3中)

Axios是对原生的AJAX进行封装，简化书写

在vue项目中，对于axios的使用，分为如下2步：

1. 安装axios: npm install axios
2. 需要使用axios时，导入axios:  import axios  'axios'（在script组件中导入）

YAPI

一个管理接口文档的平台

Nginx

主要分为2步：

1. 前端工程打包

2. 通过nginx服务器发布前端工程

按下build ->dist   直接将资源放入到html目录中

浏览器直接访问http://localhost:80

如果端口号被占用：通过conf/nginx.conf配置文件来修改端口号

打包部署

通过VS Code的NPM脚本中提供的build按钮来完整

之后会生成dist目录

将我们之前打包的前端工程dist目录下得内容拷贝到nginx的html目录下

PS: 如果80端口被占用，我们需要通过conf/nginx.conf配置文件来修改端口号。如下图所示：

后端

Maven

Maven是一款管理和构建java项目的工具

作用：

1. 依赖管理

2. 统一项目结构

3. 项目构建

 查看依赖关系：点击右键--图标--显示图

scope标签指定依赖的作用范围

主要生命周期：

• clean：移除上一次构建生成的文件

• compile：编译项目源代码

• test：使用合适的单元测试框架运行测试(junit)

• package：将编译后的文件打包，如：jar、war等

• install：安装项目到本地仓库

在同一套生命周期中，我们在执行后面的生命周期时，前面的生命周期都会执行。

详细请见：

https://blog.csdn.net/m0_51749389/article/details/137525854

SpringBoot

SpringBoot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率，底层是Spring

创建SpringBoot工程

勾选Web服务

HTTP

特点：

基于TCP 

无状态 ：每次请求-响应都是独立的

Hyper Text Transfer Protocol(超文本传输协议)

规定了浏览器与服务器之间数据传输的规则

HTTP协议又分为：请求协议和响应协议

• 请求协议：浏览器将数据以请求格式发送到服务器

  • 包括：请求行、请求头 、请求体

• 响应协议：服务器将数据以响应格式返回给浏览器

  • 包括：响应行 、响应头 、响应体

状态码：

• 200 ok 客户端请求成功

• 404 Not Found 请求资源不存在    客户端

• 500 Internal Server Error 服务端发生不可预期的错误

在HTTP1.1版本中，浏览器访问服务器的几种方式：GET、POST

GET（无请求体）

POST

GET请求和POST请求的区别：

区别方式	GET请求	POST请求
请求参数	请求参数在请求行中。 例：/brand/findAll?name=OPPO&status=1	请求参数在请求体中
请求参数长度	请求参数长度有限制(浏览器不同限制也不同)	请求参数长度没有限制
安全性	安全性低。原因：请求参数暴露在浏览器地址栏中。	安全性相对高

Tomcat

对HTTP协议的操作进行封装，使得程序员不必直接对协议进行操作(不用程序员自己写代码去解析http协议规则)

主要功能是"提供网上信息浏览服务"

在我们的SpringBoot中，引入了web运行环境(也就是引入spring-boot-starter-web起步依赖)，其内部已经集成了内置的Tomcat服务器。（主流）

SpringBootWeb请求响应

SpringBoot进行web程序开发时，它内置了一个核心的Servlet程序 DispatcherServlet，称之为 核心控制器

请求

Postman：是一款功能强大的网页调试与发送网页HTTP请求的Chrome插件。

        可以模拟浏览器向后端服务器发起任何形式(如:get、post)的HTTP请求

        使用Postman还可以在发起请求时，携带一些请求参数、请求头等信息

那么如果我们开发中，遇到了这种请求参数名和controller方法中的形参名不相同，怎么办？

解决方案：可以使用Spring提供的@RequestParam注解完成映射

掌握向服务器传递的是:

简单参数：String name , Integer age

实体参数：User user

数组参数：String[] hobby

集合参数：@RequestParam List<String> hobby

日期：@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime updateTime

JSON：post  @RequestBody //把前端传递的json数据填充到实体类中

路径参数：{id}:@PathVariable Integer id

响应

@ResponseBody

• 方法的返回值，如果是一个POJO对象或集合时，会先转换为JSON格式，在响应给浏览器

在类上添加的@RestController注解，是一个组合注解。

• @RestController = @Controller + @ResponseBody

统一响应的结果：  定义在一个Result类中

- 响应状态码：当前请求是成功，还是失败

- 状态码信息：给页面的提示信息

- 返回的数据：给前端响应的数据（字符串、对象、集合）

demo4j用于解析解析XML文件

三层架构

问题：代码全都挤在一起

代码拆分：  用接口使得传入的参数更灵活

好处：

        1. 复用性强
        2. 便于维护
        3. 利用扩展

分层解耦：

软件设计原则：高内聚低耦合。

问题：耦合 当实现类名字变了之后，创建它的类的类容也要修改  很麻烦

控制反转（ Inversion Of Control，简称IOC） 、依赖注入（Dependency Injection，简称DI ）

IOC是什么：对象的创建控制权由程序自身转移到外部（容器），这种思想称为控制反转。

使用@Component ，就可以实现类交给IOC容器管理  后面两层使用

使用@Autowired ，就可以实现程序运行时IOC容器自动注入需要的依赖对象 前面两层使用

@Component的衍生注解

• @Controller （标注在控制层类上）

• @Service （标注在业务层类上）

• @Repository （标注在数据访问层类上）

要把某个对象交给IOC容器管理，需要在对应的类上加上如下注解之一：

注解	说明	位置
@Controller	@Component的衍生注解	标注在控制器类上
@Service	@Component的衍生注解	标注在业务类上
@Repository	@Component的衍生注解	标注在数据访问类上（由于与mybatis整合，用的少）
@Component	声明bean的基础注解	不属于以上三类时，用此注解

在IOC容器中，每一个Bean都有一个属于自己的名字，默认为类名首字母小写。

那如果在IOC容器中，存在多个相同类型的bean对象，会出现什么情况呢？

如何解决上述问题呢？Spring提供了以下几种解决方案：

• @Primary  让当前bean生效

• @Qualifier  指定当前要注入的bean对象

• @Resource  按照bean的名称进行注入

问题：为什么没有找到bean对象呢？

- 使用四大注解声明的bean，要想生效，还需要被组件扫描

面试题 ： @Autowird 与 @Resource的区别

• @Autowired 是spring框架提供的注解，而@Resource是JDK提供的注解

• @Autowired 默认是按照类型注入，而@Resource是按照名称注入

MySQL

SQL（Structured Query Language，简称SQL）：结构化查询语言，它是操作关系型数据库的编程语言，定义了一套操作关系型数据库的统一标准

DBMS：数据库管理系统

关系型数据库：基于二维表存储数据的数据库

非关系型数据库：不是于二维表存储数据的数据库 Redis

主要学前三类：

图形化工具：

常用：date datetime

数据库设计：DDL

数据库操作：DML

注解

@RequestParam List<String> hobby

@RequestMapping("/emps")    抽取路径

@RequestBody 将JSON数据映射到形参的实体类对象中

@RestController = @Controller + @ResponseBody

@PathVariable Integer id   路径参数

@Mapper注解：表示是mybatis中的Mapper接口

@Component

•  @Controller （标注在控制层类上）

• @Service （标注在业务层类上）

• @Repository （标注在数据访问层类上）

• @Primary  让当前bean生效

• @Qualifier  指定当前要注入的bean对象

• @Resource  按照bean的名称进行注入

@Options(useGeneratedKeys = true,keyProperty = "id") //会自动将生成的主键值，赋值给emp对象的id属性

@Value 注解通常用于外部配置的属性注入   一个一个的进行外部属性的注入

@ConfigurationProperties 可以批量的将外部的属性配置注入到bean对象的属性中

@RestControllerAdvice：定义全局异常处理器

@RestControllerAdvice = @ControllerAdvice + @ResponseBody

@RestControllerAdvice //表示当前类为全局异常处理器

@ExceptionHandler //指定可以捕获哪种类型的异常进行处理

@WebFilter 注解，配置拦截资源的路径

@ServletComponentScan：在Filter类上面加了@WebFilter注解之后，接下来我们还需要在启动类上面加上一个注解@ServletComponentScan，通过这个@ServletComponentScan注解来开启SpringBoot项目对于Servlet组件的支持

@Transactional：在当前这个方法执行开始之前来开启事务，方法执行完毕之后提交事务

@Aspect //当前类为切面类

@Around：AOP中的通知类型 环绕通知

@PointCut注解，该注解的作用是将公共的切入点表达式抽取出来

@Order注解：控制通知的执行顺序

@Scope：进行配置Bean作用域

@Bean：管理来自第三方的bean对象（不是自定义的）

案例

部门管理

• 查询部门列表

• 删除部门

• 新增部门

• 修改部门

员工管理

• 查询员工列表(分页、条件)

• 删除员工

• 新增员工

• 修改员工

环境搭建

项目工程结构

REST风格

• GET ： 查询

• POST ：新增

• PUT ：修改

• DELETE ：删除

问题1：怎么在controller中接收请求路径中的路径参数？  @PathVariable

抽取公共路径：@RequestMapping

分页插件：PageHelper

1、在pom.xml引入依赖

2、修改EmpMapper

3、修改EmpServiceImpl

文件上传

通常上传的文件会比较大，所以需要使用 POST 提交方式

enctype必须要设置为：multipart/form-data     适合传输大型的二进制数据

阿里云OSS对象存储服务

//阿里云OSS上传文件工具类
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.io.InputStream;
import java.util.UUID;

@Component
public class AliOSSUtils {
    private String endpoint = "https://oss-cn-shanghai.aliyuncs.com";
    private String accessKeyId = "LTAI5t9MZK8iq5T2Av5GLDxX";
    private String accessKeySecret = "C0IrHzKZGKqU8S7YQcevcotD3Zd5Tc";
    private String bucketName = "web-framework01";

    /**
     * 实现上传图片到OSS
     */
    public String upload(MultipartFile multipartFile) throws IOException {
        // 获取上传的文件的输入流
        InputStream inputStream = multipartFile.getInputStream();

        // 避免文件覆盖
        String originalFilename = multipartFile.getOriginalFilename();
        String fileName = UUID.randomUUID().toString() + originalFilename.substring(originalFilename.lastIndexOf("."));

        //上传文件到 OSS
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        ossClient.putObject(bucketName, fileName, inputStream);

        //文件访问路径
        String url = endpoint.split("//")[0] + "//" + bucketName + "." + endpoint.split("//")[1] + "/" + fileName;

        // 关闭ossClient
        ossClient.shutdown();
        return url;// 把上传到oss的路径返回
    }
}

三种配置文件

1.application.properties

2.application.yml（推荐）

3.application.yaml

登录校验

必须要登录，才能使用功能

我们要完成登录校验，会涉及到web开发中的两个技术：

1. 会话技术  令牌

2. 统一拦截技术 Filter interceptor

JWT

令牌技术

JWT全称：JSON Web Token

token(JWT令牌)

三部分组成：Header(头） Payload(有效载荷）  Signature(签名）

流程：

1. 在浏览器发起请求来执行登录操作，此时会访问登录的接口，如果登录成功之后，我们需要生成一个jwt令牌，将生成的 jwt令牌返回给前端。

2. 前端拿到jwt令牌之后，会将jwt令牌存储起来。在后续的每一次请求中都会将jwt令牌携带到服务端。

3. 服务端统一拦截请求之后，先来判断一下这次请求有没有把令牌带过来，如果没有带过来，直接拒绝访问，如果带过来了，还要校验一下令牌是否是有效。如果有效，就直接放行进行请求的处理。

服务端需要统一拦截所有的请求，从而判断是否携带的有合法的JWT令牌：过滤器 拦截器

1. Servlet规范中的Filter过滤器

2. Spring提供的interceptor拦截器

过滤器

//定义一个类，实现一个标准的Filter过滤器的接口
@WebFilter(urlPatterns = "/*") 
public class DemoFilter implements Filter {
    @Override //初始化方法, 只调用一次
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init 初始化方法执行了");
    }

    @Override //拦截到请求之后调用, 调用多次
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("Demo 拦截到了请求...放行前逻辑");
        //放行
        chain.doFilter(request,response);
    }

    @Override //销毁方法, 只调用一次
    public void destroy() {
        System.out.println("destroy 销毁方法执行了");
    }
}

 拦截路径

拦截路径	urlPatterns值	含义
拦截具体路径	/login	只有访问 /login 路径时，才会被拦截
目录拦截	/emps/*	访问/emps下的所有资源，都会被拦截
拦截所有	/*	访问所有资源，都会被拦截

拦截器

拦截器是Spring框架中提供的

//自定义拦截器
@Component
public class LoginCheckInterceptor implements HandlerInterceptor {
    //目标资源方法执行前执行。 返回true：放行    返回false：不放行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle .... ");
        
        return true; //true表示放行
    }

    //目标资源方法执行后执行
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle ... ");
    }

    //视图渲染完毕后执行，最后执行
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion .... ");
    }
}

拦截路径

在拦截器中除了可以设置/**拦截所有资源外，还有一些常见拦截路径设置：

拦截路径	含义	举例
/*	一级路径	能匹配/depts，/emps，/login，不能匹配 /depts/1
/**	任意级路径	能匹配/depts，/depts/1，/depts/1/2
/depts/*	/depts下的一级路径	能匹配/depts/1，不能匹配/depts/1/2，/depts
/depts/**	/depts下的任意级路径	能匹配/depts，/depts/1，/depts/1/2，不能匹配/emps/1

执行流程

过滤器和拦截器之间的区别，其实它们之间的区别主要是两点：

• 接口规范不同：过滤器需要实现Filter接口，而拦截器需要实现HandlerInterceptor接口。

• 拦截范围不同：过滤器Filter会拦截所有的资源，而Interceptor只会拦截Spring环境中的资源。

异常处理

怎么样定义全局异常处理器？

• 定义一个类，在类上加上一个注解@RestControllerAdvice，加上这个注解就代表我们定义了一个全局异常处理器。

• 在全局异常处理器当中，需要定义一个方法来捕获异常，在这个方法上需要加上注解@ExceptionHandler。通过@ExceptionHandler注解当中的value属性来指定我们要捕获的是哪一类型的异常。

@RestControllerAdvice
public class GlobalExceptionHandler {

    //处理异常
    @ExceptionHandler(Exception.class) //指定能够处理的异常类型
    public Result ex(Exception e){
        e.printStackTrace();//打印堆栈中的异常信息

        //捕获到异常之后，响应一个标准的Result
        return Result.error("对不起,操作失败,请联系管理员");
    }
}

AOP

事务

一组操作要么同时成功，要么同时失败。 

@Transactional注解当中的两个常见的属性：

1. 异常回滚的属性：rollbackFor     指定出现何种异常类型回滚事务

2. 事务传播行为：propagation    配置事务的传播行为

默认情况下，只有出现RuntimeException(运行时异常)才会回滚事务。

什么是事务的传播行为呢？

• 就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行事务控制。

常见的事务传播行为。

属性值	含义
REQUIRED	【默认值】需要事务，有则加入，无则创建新事务
REQUIRES_NEW	需要新事务，无论有无，总是创建新事务

• REQUIRED ：大部分情况下都是用该传播行为即可。

• REQUIRES_NEW ：当我们不希望事务之间相互影响时，可以使用该传播行为。比如：下订单前需要记录日志，不论订单保存成功与否，都需要保证日志记录能够记录成功。

AOP基础

Aspect Oriented Programming（面向切面编程）   就是面向特定方法编程

AOP的作用：在程序运行期间在不修改源代码的基础上对已有方法进行增强

eg：统计程序运行时间,做法       类似动态代理

AOP的优势：

1. 减少重复代码

2. 提高开发效率

3. 维护方便

4. 代码无侵入

AOP常见的应用场景：

• 记录系统的操作日志

• 权限控制

• 事务管理：我们前面所讲解的Spring事务管理，底层其实也是通过AOP来实现的，只要添加@Transactional注解之后，AOP程序自动会在原始方法运行前先来开启事务，在原始方法运行完毕之后提交或回滚事务

示例

@Component
@Aspect //当前类为切面类
@Slf4j
public class TimeAspect {

    @Around("execution(* com.itheima.service.*.*(..))") 
    public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {
        //记录方法执行开始时间
        long begin = System.currentTimeMillis();

        //执行原始方法
        Object result = pjp.proceed();

        //记录方法执行结束时间
        long end = System.currentTimeMillis();

        //计算方法执行耗时
        log.info(pjp.getSignature()+"执行耗时: {}毫秒",end-begin);

        return result;
    }
}

AOP核心概念

连接点：JoinPoint，可以被AOP控制的方法

通知：Advice，指哪些重复的逻辑，也就是共性功能

切入点：PointCut，匹配连接点的条件

切面：Aspect，描述通知与切入点的对应关系（通知+切入点）

目标对象：Target，通知所应用的对象

Spring中AOP的通知类型：

• @Around：环绕通知，此注解标注的通知方法在目标方法前、后都被执行

• @Before：前置通知，此注解标注的通知方法在目标方法前被执行

• @After ：后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行

• @AfterReturning ： 返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执行

• @AfterThrowing ： 异常后通知，此注解标注的通知方法发生异常后执行

怎么来解决这个切入点表达式重复的问题？ 答案就是：抽取

切入点表达式

• 作用：主要用来决定项目中的哪些方法需要加入通知

常见形式：

1. execution(……)：根据方法的签名来匹配   最常用

                @Around("execution(* com.itheima.service.*.*(..))") 

1. @annotation(……) ：根据注解匹配

使用通配符描述切入点

• * ：单个独立的任意符号，可以通配任意返回值、包名、类名、方法名、任意类型的一个参数，也可以通配包、类、方法名的一部分

• .. ：多个连续的任意符号，可以通配任意层级的包，或任意类型、任意个数的参数

切入点表达式的书写建议：

• 所有业务方法名在命名时尽量规范，方便切入点表达式快速匹配。如：查询类方法都是 find 开头，更新类方法都是update开头   方便模糊搜索

在满足业务需要的前提下，尽量缩小切入点的匹配范围。如：包名匹配尽量不使用 ..，使用 * 匹配单个包

为什么要使用@annotation：那么如果我们要匹配多个无规则的方法，比如：list()和 delete()这两个方法。这个时候我们基于execution这种切入点表达式来描述就不是很方便了。而在之前我们是将两个切入点表达式组合在了一起完成的需求，这个是比较繁琐的。

@annotation实现步骤：

1. 编写自定义注解

2. 在业务类要做为连接点的方法上添加自定义注解

• 对于@Around通知，获取连接点信息只能使用ProceedingJoinPoint类型

• 对于其他四种通知，获取连接点信息只能使用JoinPoint，它是ProceedingJoinPoint的父类型

SpringBoot原理

配置优先级

优先级： 命令行参数 > 系统属性参数 > properties参数 > yml参数 > yaml参数

获取Bean对象

除了注入Bean对象外，还可以主动从IOC容器中获取到bean对象，3种常用方式：

//1.根据name获取bean
Object getBean(String name)

//2.根据类型获取bean
<T> T getBean(Class<T> requiredType)

//3.根据name获取bean（带类型转换）
<T> T getBean(String name, Class<T> requiredType)

默认情况下，IOC中的bean对象是单例  

作用域	说明
singleton	容器内同名称的bean只有一个实例（单例）（默认）
prototype	每次使用该bean时会创建新的实例（非单例）

怎样使用并定义第三方的bean呢？

• 如果要管理的bean对象来自于第三方（不是自定义的），是无法用@Component 及衍生注解声明bean的，就需要用到@Bean注解。

总结