日期：2022/09/15
学习资源：B站狂神说
学习内容：Spring
1.Spring的优点：轻量、开源、简介、免费、Ioc、Aop
(1)什么叫做轻量级框架，它与侵入式框架、非侵入式框架的区别和联系？
答：侵入式框架：引入了框架，对现有的类的结构有影响，需要实现框架某些接口或者基础某些特定的类。侵入式让用户的代码对框架产生了依赖，不利于代码的复用，当去除框架的时候，程序就无法运行。当然侵入式可以使得用户的代码与框架更好的结合，充分利用框架提供的功能。（代码结构和框架产生耦合）例子：Struts1框架, Struts1代码严重依赖于Struts1 API，属于侵入性框架。
非侵入式框架：引入了框架，对现有的类结构没有影响，不需要实现框架某些接口或者特定的类。比如Spring框架，通过配置完成依赖注入就可以使用，当我们想换个框架，只需要修改相应的配置，程序仍然可以运行。（实际上一般Spring所倡导的无侵入性一般来说都是指它的IOC框架，象楼上所说的事务管理，或者诸如AOP等，都是有侵入的，如果设计的好的话，可以把损失降低到更小，但的确不是一点侵入都没有。）
(2)IOC:(控制反转)：简单来说就是控制反转的核心及时依赖注入，也就是java是面向对象的一种语言，但是通过依赖注入到IOC容器中，我们可以将对象的创建交给Spring来管理，而我们更多的关注的是业务的实现！！！IOC更像是一种思想，由主动的编程变成了被动的接收！！
》》》IOC的实现方式：可以通过XML配置、注解…
》》》IOC的初始化过程：先读取配置文件、根据配置文件或者原数据创建与组织对象存入容器中，程序使用时再从IOC容器中去除相应的对象！！！
IOC（控制反转）是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现 控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。
Bean的作用域：singleton(默认)、prototype、request、session
**单例bean情况如果在类中声明成员变量，并且有读写操作（有状态）线程不安全但是只要把成员变量声明到方法中（无状态）单例bean就是安全的。举个例子：
**
补充：Spingboot获取bean的方法，先配置一个工具类，然后输入以下代码，即可在测试类中利用该工具类获得bean实例。
package com.blog.util;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
/**
* 实现ApplicationContextAware接口，并加入Component注解，让spring扫描到该bean
* 该类用于在普通Java类中注入bean,普通Java类中用@Autowired是无法注入bean的
*/
@Component
public class SpringUtil implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
if(SpringUtil.applicationContext == null) {
SpringUtil.applicationContext = applicationContext;
}
}
/**
* 获取applicationContext
*/
public static ApplicationContext getApplicationContext() {
return applicationContext;
}
/**
*通过name获取 Bean.
* @param name
* @return
*/
public static Object getBean(String name){
return getApplicationContext().getBean(name);
}
/**
* 通过class获取Bean.
* @param clazz
* @param <T>
* @return
*/
public static <T> T getBean(Class<T> clazz){
return getApplicationContext().getBean(clazz);
}
/**
* 通过name,以及Clazz返回指定的Bean
* @param name
* @param clazz
* @param <T>
* @return
*/
public static <T> T getBean(String name,Class<T> clazz){
return getApplicationContext().getBean(name, clazz);
}
}
注意注意注意：
alias:设置别名，即为bean对象设置别名，可以黑色还在多个别名。
import：主要也是用来将bean注入到容器中。
具体用法大家可以参照:https://www.cnblogs.com/msjhw/p/15739623.html
（3）AOP思想：在不改变原有代码的情况下，实现对原有功能的增强。
我感觉狂神的租房案例挺合适。
比如对于买房子这一行为，我们可以设计一个接口。
房主实现接口：我要买房子。
中介实现这个接口：我也实现买房子这个接口，并且将房主信息注册进来，另外再加上一些自己的收费方法！
买家：我得声明中介这个对象，向其买房子！！
这个中介就相当于代理：在这里我们主要说的是动态代理，因为动态代理包含了静态代理的
AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现 程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的 一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使 得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
面向AOP切面编程的实现方法总共有三种：
（1）通过声明SpringAPI接口实现。
（2）自定义类实现
（3）利用注解进行实现。
因为我喜欢面向注解进行开发所以在这里主要是以面向注解实现AOP编程为例：
在这里以SpringBoot为例进行测试：
（1）定义AOP的配置类：
package com.blog.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;
@Configuration
@ComponentScan("com.blog.aspect")
@EnableAspectJAutoProxy
public class AopConfig {
}
（2）定义一个切面：在这里着重讲一下Around(环绕)一定要注意他的返回值，而不是说加了这个方法就可以了，注意注意！！！！
package com.blog.aspect;
import lombok.AllArgsConstructor;
import lombok.Data;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
@Aspect //定义切面
@Component
public class LogAspect {
private Logger logger = LoggerFactory.getLogger(this.getClass());
@Pointcut("execution(* com.blog.controller.*.*(..))") //定义切入点表达式
public void log(){}
@Before("log()") //引用切入点
public void doBefore(JoinPoint joinPoint){
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();
String url = request.getRequestURL().toString();
String ip = request.getRemoteAddr();
//获得类名.方法名
String classMethod = joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName();
//获得方法参数
Object[] args = joinPoint.getArgs();
RequestLog requestLog = new RequestLog(url, ip, classMethod, args);
//打印请求信息
logger.info("Request: {}", requestLog);
}
@After("log()")
public void doAfter(){
logger.info("------------doAfter------------");
}
@AfterReturning(returning = "result", pointcut = "log()")
public void doAfterReturn(Object result){
//打印返回值
logger.info("Result: {}", result);
}
@Data
@AllArgsConstructor
public class RequestLog{ //用于封装请求信息
private String url;
private String ip;
private String classMethod;
private Object[] args;
}
}
具体结构：
（3）就可以进行测试了！配置完成！！1
2.Spring的组成：
（1）核心容器：关键配置：BeanFactory主要利用IOC模式将应用程序的配置与依赖性与实际的应用程序代码分开！！！
（2）Spring上下文：用于向Spring框架提供上下文信息。
(3) AOP:面向切面编程。最主要的就是为Spring的应用程序中的对象提供了事务管理服务！！！
（4）DAO层主要是用用于实现数据持久化操作，可用该结构来管理异常处理和不 同数据库供应商抛出的错误消息
（5）ORM（对象关系映射） ORM，即Object-Relational Mapping（对象关系映射），它的作用是在关系型数据库和业务实体对象之间作一个映射，这样，我们在具体的操作业务对象的时候，就不需要再去和复杂的SQL语句打交道，只需简单的操作对象的属性和方法。
（6）Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提 供了上下文.
(7)Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。