Spring学习个人记录

梦里梦外; 2023-09-27 09:59 11阅读 0赞

**日期：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  
![在这里插入图片描述][4d92ecde80fe42d891bf446f9d13411a.png]

\*\*单例bean情况如果在类中声明成员变量，并且有读写操作（有状态）线程不安全但是只要把成员变量声明到方法中（无状态）单例bean就是安全的。举个例子：  
![在这里插入图片描述][c28953af5b39475a8b70d665c05adccd.png]  
\*\*  
![在这里插入图片描述][83dbc624896e4ee7a5212e818c9ca620.png]

补充：Spingboot获取bean的方法，先配置一个工具类，然后输入以下代码，即可在测试类中利用该工具类获得bean实例。

![在这里插入图片描述][819c47fce1cc4ef386fa20add24db6e3.png]

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;
        }
    }

具体结构：  
![在这里插入图片描述][67c03c72a64048319dced2931922c8b9.png]

（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 实现。

[4d92ecde80fe42d891bf446f9d13411a.png]: https://img-blog.csdnimg.cn/4d92ecde80fe42d891bf446f9d13411a.png
[c28953af5b39475a8b70d665c05adccd.png]: https://img-blog.csdnimg.cn/c28953af5b39475a8b70d665c05adccd.png
[83dbc624896e4ee7a5212e818c9ca620.png]: https://img-blog.csdnimg.cn/83dbc624896e4ee7a5212e818c9ca620.png
[819c47fce1cc4ef386fa20add24db6e3.png]: https://img-blog.csdnimg.cn/819c47fce1cc4ef386fa20add24db6e3.png
[67c03c72a64048319dced2931922c8b9.png]: https://img-blog.csdnimg.cn/67c03c72a64048319dced2931922c8b9.png