SSM学习日记--尚硅谷视频（2）

Spring篇

• 2022/8/2
• • • • 1、Spring简介
      • • 1.1、Spring概述
        • 1.2、Spring家族
        • 1.3、Spring Framework
        • • 1.3.1、Spring Framework特性
          • 1.3.2、Spring Framework五大功能模块
      • 2、IOC
      • • 2.1、IOC容器
        • • 2.1.1、IOC思想
          • 2.1.2、IOC容器在Spring中的实现
        • 2.2、基于XML管理bean
• 2022/8/3
• • • • • • 2.2.2、获取bean的三种方式
          • 2.2.3、依赖注入之setter注入
          • 2.2.4、依赖注入之构造器注入
          • 2.2.5、特殊值处理
          • 2.2.6、为类类型属性赋值
          • 2.2.7、为数组类型属性赋值
          • 2.2.8、为集合、Map类型属性赋值
          • 2.2.9、p命名空间
• 2022/8/4
• • • • • • 2.2.10、引入外部属性文件
          • 2.2.11、bean的作用域
          • 2.2.12、bean的生命周期
          • 2.2.13、FactoryBean
          • 2.2.14、基于xml的自动装配
• 2022/8/5 天气：晴天
• • • • • 2.3、基于注解管理bean
        • • 2.3.1、标记与扫描
          • 2.3.2、基于注解的自动装配
      • 3、AOP
      • • 3.1、代码的增强
        • 3.2、代理模式
        • • 3.2.1、概念
          • 3.2.2、静态代理
          • 3.2.3、动态代理
• 2022/8/6 天气：阴天
• • • • • 3.3、AOP概念及相关术语
        • • 3.3.1、概述
          • 3.3.2、相关术语
          • 3.3.3、作用
        • 3.4、基于注解的AOP
        • • 3.4.1、各种注解和通知
          • 3.4.2、切入点的语法细节
        • 3.5、基于XML的AOP

2022/8/2 1、Spring简介 1.1、Spring概述

官网地址：https://spring/io/

Spring 是最受欢迎的企业级 Java 应用程序开发框架，数以百万的来自世界各地的开发人员使用
Spring 框架来创建性能好、易于测试、可重用的代码。

Spring 框架是一个开源的 Java 平台，它最初是由 Rod Johnson 编写的，并且于 2003 年 6 月首次在 Apache 2.0 许可下发布。

Spring 是轻量级的框架，其基础版本只有 2 MB 左右的大小。

Spring 框架的核心特性是可以用于开发任何 Java 应用程序，但是在 Java EE 平台上构建 web 应用程序是需要扩展的。 Spring 框架的目标是使 J2EE 开发变得更容易使用，通过启用基于 POJO编程模型来促进良好的编程实践。

1.2、Spring家族

项目列表：https://spring.io.projects

1.3、Spring Framework

Spring 基础框架，可以视为 Spring 基础设施，基本上任何其他 Spring 项目都是以 Spring Framework
为基础的。

1.3.1、Spring Framework特性

• 非侵入式：使用 Spring Framework 开发应用程序时，Spring 对应用程序本身的结构影响非常
  小。对领域模型可以做到零污染；对功能性组件也只需要使用几个简单的注解进行标记，完全不会
  破坏原有结构，反而能将组件结构进一步简化。这就使得基于 Spring Framework 开发应用程序
  时结构清晰、简洁优雅。
• 控制反转：IOC——Inversion of Control，翻转资源获取方向。把自己创建资源、向环境索取资源
  变成环境将资源准备好，我们享受资源注入。
• 面向切面编程：AOP——Aspect Oriented Programming，在不修改源代码的基础上增强代码功
  能。
• 容器：Spring IOC 是一个容器，因为它包含并且管理组件对象的生命周期。组件享受到了容器化
  的管理，替程序员屏蔽了组件创建过程中的大量细节，极大的降低了使用门槛，大幅度提高了开发
  效率。
• 组件化：Spring 实现了使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用 XML
  和 Java 注解组合这些对象。这使得我们可以基于一个个功能明确、边界清晰的组件有条不紊的搭
  建超大型复杂应用系统。
• 声明式：很多以前需要编写代码才能实现的功能，现在只需要声明需求即可由框架代为实现。
• 一站式：在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库。而且
  Spring 旗下的项目已经覆盖了广泛领域，很多方面的功能性需求可以在 Spring Framework 的基
  础上全部使用 Spring 来实现。1.3.2、Spring Framework五大功能模块

功能模块	功能介绍
Core Container	核心容器，在 Spring 环境下使用任何功能都必须基于 IOC 容器。
AOP&Aspects	面向切面编程
Testing	提供了对 junit 或 TestNG 测试框架的整合
Data Access/Integration	提供了对数据访问/集成的功能。
Spring MVC	提供了面向Web应用程序的集成功能

2、IOC 2.1、IOC容器 2.1.1、IOC思想

IOC：Inversion of Control 反转控制

①获取资源的传统方式
自己做饭：买菜、洗菜、择菜、改刀、炒菜，全过程参与，费时费力，必须清楚了解资源创建整个过程
中的全部细节且熟练掌握。

在应用程序中的组件需要获取资源时，传统的方式是组件主动的从容器中获取所需要的资源，在这样的模式下开发人员往往需要知道在具体容器中特定资源的获取方式，增加了学习成本，同时降低了开发效率。

②反转控制方式获取资源
点外卖：下单、等、吃，省时省力，不必关心资源创建过程的所有细节。

反转控制的思想完全颠覆了应用程序组件获取资源的传统方式：反转了资源的获取方向——改由容器主动的将资源推送给需要的组件，开发人员不需要知道容器是如何创建资源对象的，只需要提供接收资源的方式即可，极大的降低了学习成本，提高了开发的效率。这种行为也称为查找的被动形式。

③DI
DI：Dependency Injection，翻译过来是依赖注入。

DI 是 IOC 的另一种表述方式：即组件以一些预先定义好的方式（例如：setter 方法）接受来自于容器
的资源注入。相对于IOC而言，这种表述更直接。

所以结论是：IOC 就是一种反转控制的思想， 而 DI 是对 IOC 的一种具体实现。

2.1.2、IOC容器在Spring中的实现

1、获取IOC容器

2、获取bean对象

Spring 提供了 IOC 容器的两种实现方式：
①BeanFactory
这是 IOC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。
②ApplicationContext
BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用
ApplicationContext 而不是底层的 BeanFactory。

③ApplicationContext的主要实现类

类型名	简介
ClassPathXmlApplicationContext	通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象
FileSystemXmlApplicationContext	通过文件系统路径读取 XML 格式的配置文件创建 IOC 容器对象
ConfigurableApplicationContext	ApplicationContext 的子接口，包含一些扩展方法refresh() 和 close() ，让 ApplicationContext 具有启动、关闭和刷新上下文的能力。
WebApplicationContext	专门为 Web 应用准备，基于 Web 环境创建 IOC 容器对象，并将对象引入存入 ServletContext 域中。

2.2、基于XML管理bean

创建maven工程后添加依赖，创建pojo之后在applicationContext.xml文件中配置bean，最后在Junit中进行测试。Spring 底层默认通过反射技术调用组件类的无参构造器来创建组件对象，这一点需要注意。如果在需要无参构造器时，没有无参构造器，则会抛出下面的异常：

org.springframework.beans.factory.BeanCreationException: Error creating bean with name'helloworld' defined in class path resource [applicationContext.xml]: Instantiation of beanfailed; nested exception is org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.atguigu.spring.bean.HelloWorld]: No default constructor found; nested
exception is java.lang.NoSuchMethodException: com.atguigu.spring.bean.HelloWorld.()

今天就学了这么多，基本上是spring的一些概念，明天再进行深入的学习。

2022/8/3

今天学习了获取bean对象的三种常用方式，还学习了各种依赖注入，即对获取到的bean对象进行赋值操作。

2.2.2、获取bean的三种方式

①方式一：根据id获取
由于 id 属性指定了 bean 的唯一标识，所以根据 bean 标签的 id 属性可以精确获取到一个组件对象。

②方式二：根据类型获取

@Test
public void testHelloWorld(){
    ApplicationContext ac = new
    ClassPathXmlApplicationContext("applicationContext.xml");
    HelloWorld bean = ac.getBean(HelloWorld.class);
    bean.sayHello();
}

③方式三：根据id和类型

@Test
public void testHelloWorld(){
    ApplicationContext ac = new
    ClassPathXmlApplicationContext("applicationContext.xml");
    HelloWorld bean = ac.getBean("helloworld", HelloWorld.class);
    bean.sayHello();
}

④注意
当根据类型获取bean时，要求IOC容器中指定类型的bean有且只能有一个
当IOC容器中一共配置了两个：

根据类型获取时会抛出异常：

org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.atguigu.spring.bean.HelloWorld' available: expected single matching bean but found 2: helloworldOne,helloworldTwo

⑤扩展
如果组件类实现了接口，根据接口类型可以获取 bean 吗？
可以，前提是bean唯一
如果一个接口有多个实现类，这些实现类都配置了 bean，根据接口类型可以获取 bean 吗？
不行，因为bean不唯一
⑥结论
根据类型来获取bean时，在满足bean唯一性的前提下，其实只是看：『对象 instanceof 指定的类型』的返回结果，只要返回的是true就可以认定为和类型匹配，能够获取到。

2.2.3、依赖注入之setter注入

2.2.4、依赖注入之构造器注入

PS：constructor-arg标签还有两个属性可以进一步描述构造器参数
index属性：指定参数所在位置的索引（从0开始）
name属性：指定参数名

2.2.5、特殊值处理

①字面量赋值

②null值

是写在标签里面的而不是写在property标签中的属性

③xml实体

④CDATA节

2.2.6、为类类型属性赋值

①引用外部已声明的bean

②使用内部bean

③级联方式

2.2.7、为数组类型属性赋值

    
    
    
    
    
    
    
        
            抽烟
            喝酒
            烫头
        
    

2.2.8、为集合、Map类型属性赋值

若为Set集合类型属性赋值，只需要将其中的list标签改为set标签即可

    
    


    
    


    
    
    
    
    
    
    
        
            抽烟
            喝酒
            烫头
        
    
    
        
    

使用外部依赖util

    
    
    



    
        10010
        
    
    
        10086
        
    


    
    
    


    
    
    
    
    
    
    
        
            抽烟
            喝酒
            烫头
        
    
	

2.2.9、p命名空间

2022/8/4

今天也是学习SSM的一天，今天学习了在IOC中使用外部属性文件连接数据库，bean的作用域，bean的生命周期，FactoryBean和xml自动装配。

2.2.10、引入外部属性文件

1、在pom.xml文件中添加依赖

    mysql
    mysql-connector-java
    8.0.16
    
    
    
    com.alibaba
    druid
    1.0.31

2、添加外部属性文件jdbc.properties文件

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
jdbc.username=root
jdbc.password=123456

3、在applicationContext.xml文件中引入文件

2.2.11、bean的作用域

2.2.12、bean的生命周期

    @Test
    public void testLifeCycle() {
        // ConfigurableApplicationContext是ApplicationContext的子接口，其中扩展了刷新和关闭容器的方法
        ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext-lifecycle.xml");
        User user = ioc.getBean(User.class);
        System.out.println(user);
        ioc.close();
    }

2.2.13、FactoryBean

public class UserFactoryBean implements FactoryBean {
    @Override
    public User getObject() throws Exception {
        return new User();
    }

    @Override
    public Class getObjectType() {
        return User.class;
    }
}

public class FactoryBeanTest {

    @Test
    public void testFactoryBean() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext-factory.xml");
        User user = ioc.getBean(User.class);
        System.out.println(user);
    }
    
}

2.2.14、基于xml的自动装配

1、先模拟MVC项目，创建controller层，service层和dao层

2、在applicationContext.xml文件中配置

3、编写测试类

    
    @Test
    public void testAutoWireByXML() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext-autowire-xml.xml");
        UserController userController = ioc.getBean(UserController.class);
        userController.saveUser();
    }

------------------------加油！--------------------

2022/8/5 天气：晴天

今天没有摆烂，而且在学习计网的时候找到了一个非常好的视频进行学习，中午才开始学习SSM，今天主要学习了IOC基于注解对bean对象进行管理和AOP的前瞻——代理模式

2.3、基于注解管理bean 2.3.1、标记与扫描

四种最基本的注解

扫描组件

注意：

• 通过注解加扫描bean的id，默认值为类的小驼峰即 userController
• 可通过表示组件的注解的value属性值设置bean的自定义id

• 注解后加参数 可自定义IOC容器中bean的id
• @Controller(value = “controller”)
• 默认id 类的首字母小写

2.3.2、基于注解的自动装配

3、AOP 3.1、代码的增强

在不修改源代码的情况下，我们就需要一个代理类来给源代码添加类似于日志信息等

所以我们引入代理模式的概念

3.2、代理模式 3.2.1、概念

二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标
方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。让不属于目标方法核心逻辑
的代码从目标方法中剥离出来——解耦。调用目标方法时先调用代理对象的方法，减少对目标方法的调
用和打扰，同时让附加功能能够集中在一起也有利于统一维护。

生活中的代理：

• 广告商找大明星拍广告需要经过经纪人

• 合作伙伴找大老板谈合作要约见面时间需要经过秘书

• 房产中介是买卖双方的代理

  相关术语：

  代理：将非核心逻辑剥离出来以后，封装这些非核心逻辑的类、对象、方法。
  目标：被代理“套用”了非核心逻辑代码的类、对象、方法。

3.2.2、静态代理

@Override
    public int add(int i, int j) {
        System.out.println("日志, 方法:add, 参数: " + i + "," + j);
        int result = calculatorImpl.add(i, j);
        System.out.println("日志, 方法:add, 结果: " + result);
        return result;
    }

即在代理类中写死了，完全不具备任何的灵活性

将日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理类来实现。

这就需要使用动态代理技术了

3.2.3、动态代理

利用反射机制实现 (反射大法真的香，可惜笔者不太会555)

引入动态代理是为了更好的理解AOP机制

public class ProxyFactory {

    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    public Object getProxy() {
        // jdk动态代理
        
        ClassLoader classLoader = this.getClass().getClassLoader();
        Class[] interfaces = target.getClass().getInterfaces();
        InvocationHandler h = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Object result = null;
                try {
                    System.out.println("日志, 方法：" + method.getName() + ", 参数:" + Arrays.toString(args));
                    // proxy表示代理对象, method表示要执行的方法, args表示要执行的方法的参数列表
                    result = method.invoke(target, args);
                    System.out.println("日志, 方法：" + method.getName() + ", 结果:" + result);
                } catch (Exception e) {
                    e.printStackTrace();
                    System.out.println("日志, 方法：" + method.getName() + ", 异常:" + e);
                }  finally {
                    System.out.println("日志, 方法：" + method.getName() + ",方法执行完毕");
                }
                return result;
            }
        };
        return Proxy.newProxyInstance(classLoader, interfaces, h);
    }
}

------------------------今天就学到这里吧，明天再学习AOP-----------

2022/8/6 天气：阴天

今天学习了AOP概念及相关术语，还有基于注解的AOP和基于XML的AOP配置。

3.3、AOP概念及相关术语 3.3.1、概述

AOP（Aspect Oriented Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面
向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况
下给程序动态统一添加额外功能的一种技术。

3.3.2、相关术语

①横切关注点
从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方
法进行多个不同方面的增强。

这个概念不是语法层面天然存在的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横
切关注点。

②通知
每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。
a>前置通知：在被代理的目标方法前执行
b>返回通知：在被代理的目标方法成功结束后执行（寿终正寝）
c>异常通知：在被代理的目标方法异常结束后执行（死于非命）
d>后置通知：在被代理的目标方法最终结束后执行（盖棺定论）
e>环绕通知：使用try…catch…finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所
有位置

③切面
封装通知方法的类。

④目标
被代理的目标对象。

⑤代理
向目标对象应用通知之后创建的代理对象。

⑥连接点
这也是一个纯逻辑概念，不是语法定义的。就是我们的通知需要放在核心业务代码的哪个位置

⑦切入点
定位连接点的方式。
每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物（从逻辑上来说）。
如果把连接点看作数据库中的记录，那么切入点就是查询记录的 SQL 语句。
Spring 的 AOP 技术可以通过切入点定位到特定的连接点。
切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条
件。

3.3.3、作用

• 简化代码：把方法中固定位置的重复的代码抽取出来，让被抽取的方法更专注于自己的核心功能，
  提高内聚性。
• 代码增强：把特定的功能封装到切面类中，看哪里有需要，就往上套，被套用了切面逻辑的方法就
  被切面给增强了。

3.4、基于注解的AOP 3.4.1、各种注解和通知

@Component
@Aspect // 将当前组件标识为切面
public class LoggerAspect {

    

    // 公共的切入点表达式
    @Pointcut("execution(* com.fzk.spring.aop.annotation.CalculatorImpl.*(..))")
    public void pointCut() {

    }

    // @Before("execution(public int com.fzk.spring.aop.annotation.CalculatorImpl.add(int, int))")
    @Before("pointCut()")
    public void beforeAdviceMethod(JoinPoint joinPoint) {
        
        Signature signature = joinPoint.getSignature();
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect, 方法名: " + signature.getName() + ", 参数: " + Arrays.toString(args));
    }

    @After("pointCut()")
    public void afterAdviceMethod(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println("LoggerAspect, 方法名: " + signature.getName() + ", 执行完毕");
    }

    @AfterReturning(value = "pointCut()", returning = "result")
    public void afterReturningAdviceMethod(JoinPoint joinPoint, Object result) {
        Signature signature = joinPoint.getSignature();
        System.out.println("LoggerAspect, 方法名: " + signature.getName() + ", 结果: " + result);
    }

    @AfterThrowing(value = "pointCut()", throwing = "exception")
    public void afterThrowAdviceMethod(JoinPoint joinPoint, Throwable exception) {
        Signature signature = joinPoint.getSignature();
        System.out.println("LoggerAspect, 方法:" + signature.getName() + ", 异常:" + exception);
    }

    @Around("pointCut()")
    public Object aroundAdviceMethod(ProceedingJoinPoint joinPoint) {
        Object result = null;
        try {
            System.out.println("环绕通知-->前置通知");
            // 表示目标对象方法的执行
            result = joinPoint.proceed();
            System.out.println("环绕通知-->返回通知");
        } catch (Throwable e) {
            e.printStackTrace();
            System.out.println("环绕通知-->异常通知");
        } finally {
            System.out.println("环绕通知-->后置通知");
        }
        return result;
    }

}

基于注解的AOP在XML中的配置如下

3.4.2、切入点的语法细节

具体的可以看尚硅谷的资料，在文章的评论区。

3.5、基于XML的AOP

基本上与3.4节一致，只不过是把注解去掉，在配置文件中配置。代码如下

------------------------今天是非常充实的一天，希望明天继续保持------------------------------