Wait Together

spring

title: 2 spring

date: ‘2023-3-29’

文章目录

- date: '2023-3-29'
- - 一、引言
  - - 1.1 原生web开发中存在哪些问题？
  - 二、Spring框架
  - - 2.1 概念
    - 2.2 访问与下载
  - 三、Spring架构组成
  - 四、山寨版的Spring容器
  - - 4.1准备工作
    - 4.2 山寨IOC容器
    - 4.3 配置文件告诉容器管理哪些bean
    - 4.4 相关类
    - 4.5 测试容器
  - 五、构建Maven项目
  - - 5.1 新建项目
    - 5.2 选择Maven目录
  - 六、Spring环境搭建
  - - 6.1 pom.xml中引入Spring常用依赖
    - 6.2 创建Spring配置文件
  - 七、Spring工厂编码
  - 八、依赖与配置文件详解
  - - 8.1 Spring依赖关系
    - 8.2 schema
  - 九、IoC（Inversion of Control ）控制反转【`重点`】
  - - 9.1 项目中强耦合问题
    - 9.2 解决方案
    - 9.3 IOC 接口
    - - 1.IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂
      - 2.Spring 提供 IOC 容器实现两种方式：（两个接口）
      - 3.IOC操作bean管理
  - 十、DI（Dependency Injection）依赖注入【`重点`】
  - - 10.1 概念
    - 10.2 Set注入
    - - 10.2.1 定义目标Bean类型
      - 10.2.2 基本类型 + 字符串类型 + 日期类型
      - 10.2.3 容器类型
      - 10.2.4 自建类型
    - 10.3 构造注入【了解】
    - - 10.3.1 定义目标Bean类型
      - 10.3.2 注入
    - 10.4 自动注入
  - 十一、Bean细节
  - - 11.1 控·制简单对象的单例、多例模式 ----- bean的作用域
    - 11.2 FactoryBean创建复杂对象
    - - 11.2.1 实现FactoryBean接口
      - 11.2.2 配置spring-context.xml
      - 11.2.3 特例
  - 十二、Spring工厂特性
  - - 12.1 饿汉式创建优势 --- 面试题为什么spring bean 默认是单例
    - 12.2 生命周期方法 ---- 面试题 spring bean 的声明周期是什么非常重要
    - 12.3 生命周期注解
    - 12.4 生命周期阶段
  - 十三、代理设计模式
  - - 13.1 概念
    - 13.2 静态代理设计模式
    - 13.3 动态代理设计模式
    - - 13.3.1 JDK动态代理实现（基于接口）
      - 13.3.2 CGlib动态代理实现（基于继承）
  - 十四、面向切面编程【`重点`】
  - - 14.1 概念
    - 14.2 AOP开发术语
    - 14.3 作用
    - 14.4 环境搭建
    - 14.5 开发流程
    - 14.6 AOP小结
    - 14.7 通知类【可选】
    - 14.8 通配切入点
    - 14.9 JDK和CGLIB选择
    - 14.10 后处理器
    - - 14.10.1 后处理器定义
      - 14.10.2 配置后处理器
      - 14.10.3 bean生命周期
      - 14.10.4 动态代理源码(了解)
  - 十五、Spring + MyBatis【`重点`】
  - - 15.1 我的整合步骤
    - 15.2.相关配置文件
    - 15.3 整合 logback 日志
  - 十六、事务【`重点`】
  - - 16.1咱们先来看基于xml 首先在是spring 的配置文件配置事务管理器
    - 16.2 基于注解的事务配置
    - 16.3 事务属性
    - - 16.3.1 隔离级别
      - 16.3.1.1 概念
        
        16.3.1.2 特性
        
        16.3.1.3 并发问题
      - 16.3.2 传播行为
      - 16.3.3 读写性
      - 16.3.4 事务超时
      - 16.3.5 事务回滚
  - 十七、注解开发
  - - 17.1 声明bean
    - 17.2 注入(DI)
    - 17.5 AOP开发
    - - 17.5.1 注解使用
      - 17.5.2 配置
  - 十八、集成JUnit
  - - 18.1 导入依赖
    - 18.2 编码
  - 十九、个人扩展
  - 二十个人源码解析

一、引言

1.1 原生web开发中存在哪些问题？

传统Web开发存在硬编码所造成的过度程序耦合（例如：Service中作为属性Dao对象）。

UserDao userdao = new UserDaoImpl();

部分Java EE API较为复杂，使用效率低（例如：JDBC开发步骤，Servlet的开发步骤）。

侵入性强，移植性差（例如：DAO实现的更换，从Connection到SqlSession）。

二、Spring框架

2.1 概念

Spring是一个项目管理框架，同时也是一套Java EE解决方案。

Spring是众多优秀设计模式的组合（工厂、单例、代理、适配器、包装器、观察者、模板、策略）。

Spring并未替代现有框架产品，而是将众多框架进行有机整合，简化企业级开发，俗称"胶水框架"。

2.2 访问与下载

官方网站：https://spring.io/

下载地址：http://repo.spring.io/release/org/springframework/spring/

三、Spring架构组成

Spring架构由诸多模块组成，可分类为

核心技术：依赖注入，事件，资源，i18n，验证，数据绑定，类型转换，SpEL，AOP。

测试：模拟对象，TestContext框架，Spring MVC测试，WebTestClient。

数据访问：事务，DAO支持，JDBC，ORM，封送XML。

Spring MVC和 Spring WebFlux Web框架。

集成：远程处理，JMS，JCA，JMX，电子邮件，任务，调度，缓存。

语言：Kotlin，Groovy，动态语言。

Spring架构组成

GroupId	ArtifactId	说明
org.springframework	spring-beans	Beans 支持，包含 Groovy
org.springframework	spring-aop	基于代理的AOP支持
org.springframework	spring-aspects	基于AspectJ 的切面
org.springframework	spring-context	应用上下文运行时，包括调度和远程抽象
org.springframework	spring-context-support	支持将常见的第三方类库集成到 Spring 应用上下文
org.springframework	spring-core	其他模块所依赖的核心模块
org.springframework	spring-expression	Spring 表达式语言，SpEL
org.springframework	spring-instrument	JVM 引导的仪表（监测器）代理
org.springframework	spring-instrument-tomcat	Tomcat 的仪表（监测器）代理
org.springframework	spring-jdbc	支持包括数据源设置和 JDBC 访问支持
org.springframework	spring-jms	支持包括发送/接收JMS消息的助手类
org.springframework	spring-messaging	对消息架构和协议的支持
org.springframework	spring-orm	对象/关系映射，包括对 JPA 和 Hibernate 的支持
org.springframework	spring-oxm	对象/XML 映射（Object/XML Mapping，OXM）
org.springframework	spring-test	单元测试和集成测试支持组件
org.springframework	spring-tx	事务基础组件，包括对 DAO 的支持及 JCA 的集成
org.springframework	spring-web	web支持包，包括客户端及web远程调用
org.springframework	spring-webmvc	REST web 服务及 web 应用的 MVC 实现
org.springframework	spring-webmvc-portlet	用于 Portlet 环境的MVC实现
org.springframework	spring-websocket	WebSocket 和 SockJS 实现，包括对 STOMP 的支持
org.springframework	spring-jcl	Jakarta Commons Logging 日志系统

四、山寨版的Spring容器

创建容器，从容器得到对象 ,而不是程序员自己new 对象，从而实现对象间的解耦

4.1准备工作

UserService

public interface UserService {

    public void addUser();
}

UserServiceImpl

    @Override
    public void addUser() {
        //使用 spring容器 之前的做法  是 在这里 new 一个 dao 对象  程序员自己new

        //UserDao userDao = new UserJdbcDaoImpl();
        //现在 需求变了 要使用mybatis 操作数据库      硬编码     耦合度太高   我们希望 不改代码 来改变底层的实现
        userDao = new UserMybatisDaoImpl();

        userDao.addUser();

    }

UserDao

public interface UserDao {
    void addUser();

}

UserJdbcDaoImpl

public class UserJdbcDaoImpl implements UserDao {
    @Override
    public void addUser() {
        System.out.println("使用jdbc来添加用户");
    }
}

UserMybatisDaoImpl

public class UserMybatisDaoImpl implements UserDao {
    @Override
    public void addUser() {
        System.out.println("使用mybatis来添加用户");
    }
}

原来咱们的做法没有spring容器的时候

    @Test
    public void test1(){
        //使用 spring  容器之前的 做法   自己 new
        UserService userService = new UserServiceImpl();

        userService.addUser();
    }

4.2 山寨IOC容器

引入spring 容器，从容器中获取对象

MyClassPathXmlApplicationContext

package com.glls.java2301.framework;

import com.glls.java2301.dao.UserDao;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;

/**
 * @date 2023/4/19
 * @desc   山寨版IOC容器  来模拟 真实的  基于XML的 spring 容器
 */
public class MyClassPathXmlApplicationContext {

    //用于 存放 解析完 xml文件之后的   bean 的 信息， 以 beanId  为key  以BeanDefinition 为值
    private Map<String,BeanDefinition> beansMap = new HashMap<>();

    //这个map 用于存放 spring 容器 创建出来的对象   在容器里面创建出来的对象 叫 bean
    // 这个map 以 beanId 为 key  以反射创建出来的对象 为值
    private Map<String,Object> objectMap = new HashMap<>();



    public MyClassPathXmlApplicationContext() {
    }


    public MyClassPathXmlApplicationContext(String xmlPath) throws DocumentException, ClassNotFoundException, InstantiationException, IllegalAccessException, InvocationTargetException {
        //这个构造方法  创建 容器对象 , 创建容器对象的时候   要把容器管理的bean 对象 也创建好
        //咱们就得告诉 Spring 容器  它所管理的bean对象 有哪些 ，通常 咱们会通过  xml , 注解，  java 配置类
        //这些方式 告诉 spring 容器  管理的 bean 有哪些 ，这里 咱们 采用的方式 是 xml 的方式  告知spring 管理
        // 哪些bean   所以 现在 咱们要做的事情  就是  解析 xml 文件  ，得到 要创建的 bean 的 信息

        //1. 解析 xml 文件  得到 bean的信息  把bean 的信息 封装到 BeanDefinition  ,每个bean 都会有自己的
        //beanDefinition  ， 咱们把 很多 bean 的 beanDefinition 放入一个 map 中
        parseXml(xmlPath);


        //2.从 beansMap 中 获取bean 的信息 通过反射 创建对象 将创建出来的对象 放入 objectMap
        createObject();

        //3. di    依赖注入   第二部创建的对象的属性时没有值的
        di(); //dependency injection  属性注入

    }

    //依赖注入  通过反射 调用对象的 set 方法  给对象的属性赋值
    private void di() throws ClassNotFoundException, InvocationTargetException, IllegalAccessException {
        Set<Map.Entry<String, BeanDefinition>> entrySet = beansMap.entrySet();

        Iterator<Map.Entry<String, BeanDefinition>> iterator = entrySet.iterator();

        while (iterator.hasNext()){
            Map.Entry<String, BeanDefinition> beanDefinitionEntry = iterator.next();

            String beanId = beanDefinitionEntry.getKey();

            BeanDefinition beanDefinition = beanDefinitionEntry.getValue();

            //得到的bean 的property 集合
            Map<String, PropertyDefinition> propsMap = beanDefinition.getPropsMap();

            Set<Map.Entry<String, PropertyDefinition>> proSet = propsMap.entrySet();

            Iterator<Map.Entry<String, PropertyDefinition>> proIter = proSet.iterator();

            while (proIter.hasNext()){
                Map.Entry<String, PropertyDefinition> propertyDefinitionEntry = proIter.next();
                //得到 property 的name
                String proName = propertyDefinitionEntry.getKey();
                PropertyDefinition propertyDefinition = propertyDefinitionEntry.getValue();

                //ref 指向 属性对应的beanId
                String ref = propertyDefinition.getRef();

                //根据属性名 得到set方法  通过set方法给对象的属性赋值
                //setUserDao
                String setMethodName = "set" + proName.substring(0,1).toUpperCase()+proName.substring(1);

                //通过反射 得到方法对象
                String beanClass = beanDefinition.getBeanClass();
                Class<?> aClass = Class.forName(beanClass);

                Method[] declaredMethods = aClass.getDeclaredMethods();

                for(Method m:declaredMethods){
                    //判断对象中 有没有这个 set 方法
                    if(m.getName().equals(setMethodName)){
                        //表示 有这个 set 方法

                        //得到对象  给这个对象的属性赋值  要反射调用这个对象的 set 方法
                        Object o = objectMap.get(beanId);

                        //得到 set 方法的参数
                        Object para = objectMap.get(ref);

                        //反射调用set 方法 给 对象o 的属性赋值
                        // userService.setUserDao(para);
                        m.invoke(o,para);
                    }
                }



            }
        }
    }

    //创建对象
    private void createObject() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        //通过反射创建对象 要拿到类的全路径信息
        Set<Map.Entry<String, BeanDefinition>> entrySet = beansMap.entrySet();

        Iterator<Map.Entry<String, BeanDefinition>> iterator = entrySet.iterator();

        while (iterator.hasNext()){
            Map.Entry<String, BeanDefinition> bean = iterator.next();

            String beanId = bean.getKey();
            BeanDefinition beanDefinition = bean.getValue();

            //得到类的全路径名
            String beanClass = beanDefinition.getBeanClass();
            //通过反射创建对象
            Object o = Class.forName(beanClass).newInstance();

            //将创建好的对象 存入 obejctMap

            objectMap.put(beanId,o);
        }


    }

    private void parseXml(String xmlPath) throws DocumentException {
        //读取配置文件 得到流对象
        InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream(xmlPath);

        //使用dom4j的api
        SAXReader saxReader = new SAXReader();
        //得到文档对象
        Document doc = saxReader.read(resourceAsStream);
        //得到根节点
        Element rootElement = doc.getRootElement();
        //遍历根节点
        Iterator<Element> iterator = rootElement.elementIterator();

        while (iterator.hasNext()){
            Element bean = iterator.next();

            String beanId = bean.attributeValue("id");
            String beanClass = bean.attributeValue("class");

            //System.out.println(beanId+"---"+beanClass);

            //把解析出来的信息 存入 BeanDefinition 中

            BeanDefinition beanDefinition = new BeanDefinition();
            beanDefinition.setBeanId(beanId);
            beanDefinition.setBeanClass(beanClass);

            //遍历bean 标签的子标签
            Iterator<Element> proIterator = bean.elementIterator();


            while (proIterator.hasNext()){
                Element pro = proIterator.next();

                String proName = pro.attributeValue("name");
                String proRef = pro.attributeValue("ref");
                //将bean 的 子节点 属性信息 封装到 PropertyDefinition 中
                PropertyDefinition propertyDefinition = new PropertyDefinition();

                propertyDefinition.setName(proName);
                propertyDefinition.setRef(proRef);

                //将属性信息 封装到 BeanDefinition 中的 propsMap
                Map<String, PropertyDefinition> propsMap = beanDefinition.getPropsMap();

                propsMap.put(proName,propertyDefinition);
            }

            //将这个 bean 的定义信息 封装到 beansMap
            beansMap.put(beanId,beanDefinition);

        }
    }


    //从容器拿对象的方法
    public Object getBean(String beanName) {
        return objectMap.get(beanName);
    }
}

4.3 配置文件告诉容器管理哪些bean

4.4 相关类

BeanDefinition

package com.glls.java2301.framework;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.HashMap;
import java.util.Map;

/**
 * @date 2023/4/19
 * @desc  bean 的定义信息  来封装bean 的 信息
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class BeanDefinition {

    //解析xml   解析出来的数据 封装到这个类的对象中

    private String beanId;   // bean 的 名字 bean 在容器中的标识

    private String beanClass;  // 封装bean 的 全路径

    private Map<String,PropertyDefinition> propsMap = new HashMap<>();

}

PropertyDefinition

@Data
@AllArgsConstructor
@NoArgsConstructor
public class PropertyDefinition {

    //property 节点的 name 属性值
    private String name;
    //property 节点的 ref 属性值
    private String ref;

}

4.5 测试容器

 @Test
    public void test2() throws DocumentException, ClassNotFoundException, InstantiationException, IllegalAccessException, InvocationTargetException {
        //山寨版的IOC容器
        // 由容器 来 创建  管理 对象

        // 创建咱们 的IOC 容器， 从容器中 获取 对象  ，这里 咱们模拟的情况是
        //容器 创建好了   里面的bean 也创建好了  ， 可以直接用了
        String config= "applicationContext.xml";
        //创建容器对象  告知容器对象扫描的 xml 配置文件    ，xml 文件中 记录了 spring 容器要管理的 bean的信息
        MyClassPathXmlApplicationContext applicationContext = new MyClassPathXmlApplicationContext(config);

        //UserDao userDao = (UserDao) applicationContext.getBean("userJdbcDao");
        //UserDao userDao2 = (UserDao) applicationContext.getBean("userMybatisDao");
        UserService userService = (UserService) applicationContext.getBean("userService");



        //userDao.addUser();

        //userDao2.addUser();

        userService.addUser();
    }

手写 ioc 容器 – 基于 xml 版本的目的理解 ioc 容器

详见 springday1 案例

后面有时间再带大家写一个基于注解版本的理解 bean的生命周期

五、构建Maven项目

5.1 新建项目

在工程下创建module

5.2 选择Maven目录

注意GAV坐标
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HY3THQDD-1683019927703)(Pictures/image-20230420091510936.png)]

六、Spring环境搭建

6.1 pom.xml中引入Spring常用依赖


<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation=
         "http://maven.apache.org/POM/4.0.0 
          http://maven.apache.org/xsd/maven-4.0.0.xsd">
  
    <modelVersion>4.0.0modelVersion>

    <groupId>com.qfgroupId>
    <artifactId>hello-springartifactId>
    <version>1.0-SNAPSHOTversion>

    <dependencies>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.2.9.RELEASEversion>
        dependency>
    dependencies>
project>

6.2 创建Spring配置文件

命名无限制，约定俗成命名有：spring-context.xml、applicationContext.xml、beans.xml

这里咱们创建beans1.xml


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
   
beans>

七、Spring工厂编码

定义目标Bean类型

注意：spring容器知识帮助咱们创建对象管理对象，所以这个对象对应的类还是需要咱们自己创建好

public class MyClass{
    public void show(){
        System.out.println("HelloWorld");
    }
}

beans1.xml中的< beans >内部配置bean标签


 <bean id="myClass" class="com.glls.java2301.pojo.MyClass">bean>

调用Spring工厂API（ApplicationContext接口）

public class TestSpringIocFactory {


    @Test
    public void test1(){
        //1.创建spring 容器，通过配置文件 beans1.xml 告知容器 要管理的 bean 有哪些
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans1.xml");
		  //2. 通过id获取bean对象
        //MyClass myClass = (MyClass) applicationContext.getBean("myClass");
        MyClass myClass = applicationContext.getBean("myClass", MyClass.class);
		//3. 使用对象
        myClass.show();
    }
}

八、依赖与配置文件详解

Spring框架包含多个模块，每个模块各司其职，可结合需求引入相关依赖Jar包实现功能。

8.1 Spring依赖关系

Spring常用功能的Jar包依赖关系

注意：Jar包彼此存在依赖，只需引入最外层Jar即可由Maven自动将相关依赖Jar引入到项目中。

8.2 schema

配置文件中的顶级标签中包含了语义化标签的相关信息

xmlns：语义化标签所在的命名空间。

xmlns:xsi：XMLSchema-instance 标签遵循Schema标签标准。

xsi:schemaLocation：xsd文件位置，用以描述标签语义、属性、取值范围等。

九、IoC（Inversion of Control ）控制反转【`重点`】

Inverse Of Controll：控制反转

反转了依赖关系的满足方式，由之前的自己创建依赖对象，变为由工厂推送。(变主动为被动，即反转)

解决了具有依赖关系的组件之间的强耦合，使得项目形态更加稳健

补充：什么是IOC

1.控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理

2.使用 IOC 目的：为了耦合度降低

3.入门案例就是 IOC 实现

IOC 底层原理

xml 解析、工厂模式、反射

9.1 项目中强耦合问题

public class UserDAOImpl implements UserDAO{....}

public class UserServiceImpl implements UserService {
    // !!!强耦合了UserDAOImpl!!!,使得UserServiceImpl变得不稳健!!
    private UserDAO userDAO= new UserDAOImpl();
    @Override
    public User queryUser() {
        return userDAO.queryUser();
    }
    ....
}

9.2 解决方案

// 不引用任何一个具体的组件(实现类)，在需要其他组件的位置预留存取值入口(set/get)
public class UserServiceImpl implements UserService {
    // !!!不再耦合任何DAO实现!!!,消除不稳健因素!!
    private UserDAO userDAO；
    // 为userDAO定义set/get,允许userDAO属性接收spring赋值
    //Getters And Setters
    @Override
    public User queryUser() {
        return userDAO.queryUser();
    }
    ....
}




<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    
    <bean id="myClass" class="com.glls.java2301.pojo.MyClass">bean>


    <bean id="userJdbcDao" class="com.glls.java2301.dao.impl.UserJdbcDaoImpl" >bean>

    <bean id="userMybatisDao" class="com.glls.java2301.dao.impl.UserMybatisDaoImpl">bean>

    <bean  id="userService" class="com.glls.java2301.service.impl.UserServiceImpl">
        
         
        <property  name="userDao" ref="userJdbcDao">property>
    bean>
beans>

此时，如果需要更换其他UserDAO实现类，则UserServiceImpl不用任何改动！

则此时的UserServiceImpl组件变得更加稳健！

9.3 IOC 接口

1.IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂

2.Spring 提供 IOC 容器实现两种方式：（两个接口）

BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用
- 加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象
ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人员进行使用
- 加载配置文件时候就会把在配置文件对象进行创建

下面这个图是找到ApplicationContext 类，按 F4 可以展示这个接口的实现类信息

3.IOC操作bean管理

Bean的管理指的是两个操作：1.Spring创建对象 2.Spring注入属性

Bean的常见的管理操作有三种方式：1.基于 xml 配置文件方式实现 2.基于注解方式实现 3.基于配置类

十、DI（Dependency Injection）依赖注入【`重点`】

10.1 概念

在Spring创建对象的同时，为其属性赋值，称之为依赖注入。

10.2 Set注入

创建对象时，Spring工厂会通过Set方法为对象的属性赋值。

10.2.1 定义目标Bean类型

public class User {
    private Integer id;
    private String password;
    private String sex;
    private Integer age;
    private Date bornDate;
    private String[] hobbys;
    private Set<String> phones;
    private List<String> names;
    private Map<String,String> countries;
    private Properties files;
    //Getters And Setters
}

10.2.2 基本类型 + 字符串类型 + 日期类型

 <bean id="user" class="com.glls.java2301.pojo.User">
    
    <property name="id" value="1001" />
    <property name="password" value="123456" />
    <property name="sex" value="male" />
    <property name="age" value="20" />
    <property name="bornDate" value="1990/1/1" />
bean>

10.2.3 容器类型

<bean id="u1" class="com.qf.spring.part1.injection.User">	
	
    <property name="hobbys">
        <array>
            <value>Runvalue>
            <value>Swimvalue>
            <value>Climbvalue>
        array>
    property>

    
    <property name="phones">
        <set>
            <value>13777777777value>
            <value>13888888888value>
            <value>13999999999value>
        set>
    property>

    
    <property name="names">
        <list>
            <value>tomvalue>
            <value>jackvalue>
            <value>marryvalue>
        list>
    property>

    
    <property name="countries">
        <map>
            <entry key="CN" value="China" />
            <entry key="US" value="America" />
            <entry key="KR" value="Korea" />
        map>
    property>
    
    
    <property name="files">
        <props>
            <prop key="first">Oneprop>
            <prop key="second">Twoprop>
            <prop key="third">Threeprop>
        props>
    property>
bean>

10.2.4 自建类型


    <bean id="address" class="com.glls.java2301.pojo.Address">
        <property name="city"  value="郑州">property>
        <property name="province"  value="河南">property>
    bean>


   <bean id="user" class="com.glls.java2301.pojo.User">
    <property name="address" ref="address">property>
bean>

10.3 构造注入【了解】

创建对象时，Spring工厂会通过构造方法为对象的属性赋值。

10.3.1 定义目标Bean类型

public class Student {
    private Integer id;
    private String name;
    private String sex;
    private Integer age;
  
    //Constructors
  	public Student(Integer id , String name , String sex , Integer age){
      	this.id = id;
    	this.name = name;
  	    this.sex = sex;
	    this.age = age;
    }
}

10.3.2 注入

 
<bean id="u3" class="com.qf.zcg.spring.day1.t2.ioc.Student">
    <constructor-arg name="id" value="1234" /> 
    <constructor-arg name="name" value="tom" />
    <constructor-arg name="age" value="20" />
    <constructor-arg name="sex" value="male" />
bean>

10.4 自动注入

不用在配置中指定为哪个属性赋值，及赋什么值.

由spring自动根据某个 “原则” ，在工厂中查找一个bean，为属性注入属性值

也叫自动装配根据装配规则（属性名和属性类型） spring 自动将匹配的属性值进行注入

演示过程

1.根据属性名称自动注入

		在  bean  标签 使用 autowire 配置自动装配，autowire 属性 常用两个值：

		byName   根据属性名称注入     注入值的 bean 的 id 和  类的属性名一样

		byType     根据属性类型注入   如果 容器内 有多个这个类型的bean 那么 容器如果不知道注入哪一个 就会报错

public class UserServiceImpl implements UserService {

    private UserDao userDao;
    ......
}


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userService" class="com.glls.java2301.service.impl.UserServiceImpl" autowire="byType">

        
    bean>

    <bean id="userJdbcDao" class="com.glls.java2301.dao.impl.UserJdbcDaoImpl">bean>



beans>


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userService" class="com.glls.java2301.service.impl.UserServiceImpl" autowire="byName">

        
    bean>

  


    <bean id="userDao" class="com.glls.java2301.dao.impl.UserMybatisDaoImpl">bean>
beans>

十一、Bean细节

11.1 控·制简单对象的单例、多例模式 ----- bean的作用域

在spring 容器里设置 bean 实例是单例还是多例，默认情况下 bean 是单例的

配置< bean scope=“singleton | prototype” />


 <bean id="userService" class="com.glls.java2301.service.impl.UserServiceImpl" autowire="byName" scope="prototype">

注意：需要根据场景决定对象的单例、多例模式。
可以共用：Service、DAO、SqlSessionFactory（或者是所有的工厂）。
不可共用：Connection、SqlSession、ShoppingCart。

11.2 FactoryBean创建复杂对象

注意和前面的 BeanFactory 的区别

补充：spring有两种类型的bean ，一种是普通bean ，另外一种是工厂bean (FactoryBean)

普通的bean : 在配置文件中定义的bean的类型就是返回类型

工厂bean 在配置文件中定义的bean类型可以和返回的bean类型不一样

作用：让Spring可以创建复杂对象、或者无法直接通过反射创建的对象。

FactoryBean解决复杂对象创建

11.2.1 实现FactoryBean接口

接口方法描述

注意：isSingleton方法的返回值，需根据所创建对象的特点决定返回true/false。
例如：Connection 不应该被多个用户共享，返回false。
例如：SqlSessionFactory 重量级资源，不该过多创建，返回true。

package com.glls.java2301.factorybean;

import org.springframework.beans.factory.FactoryBean;

import java.sql.Connection;
import java.sql.DriverManager;

/**
 * @date 2023/4/20
 * @desc 一种特殊的 bean ,用来创建其他 bean 的 bean
 *
 * 这种 bean 称为 工厂bean ,  一般是用来 创建 复杂对象的 bean
 */
public class MyFactoryBean implements FactoryBean<Connection> {
    @Override
    public Connection getObject() throws Exception {

        Class.forName("com.mysql.cj.jdbc.Driver");

        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/ssm?characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true", "root", "123456");

        return connection;
    }

    @Override
    public Class<?> getObjectType() {
        return Connection.class;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
}

11.2.2 配置spring-context.xml

配置与获取方式

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


    <!--研究 工厂 bean
        spring有两种类型的bean ，一种是 普通bean ，另外一种是 工厂bean (FactoryBean)

普通的bean : 在配置文件中定义的bean的类型 就是返回类型

工厂bean 在配置文件中定义的bean类型可以和返回的bean类型不一样

      -->
    <bean id="myFactoryBean" class="com.glls.java2301.factorybean.MyFactoryBean"></bean>
</beans>

11.2.3 特例

获取FactoryBean接口的实现类对象，而非getObject()所生产的对象。

十二、Spring工厂特性

12.1 饿汉式创建优势 — 面试题为什么spring bean 默认是单例

工厂创建之后，会将Spring配置文件中的所有对象都创建完成（饿汉式）。

提高程序运行效率。避免多次IO，减少对象创建时间。（概念接近连接池，一次性创建好，使用时直接获取）

如果默认是多例bean 首先创建多例bean 会消耗资源还会占用堆空间

12.2 生命周期方法 ---- 面试题 spring bean 的声明周期是什么非常重要

什么生命周期？

bean 对象从创建到销毁的过程

步骤

bean 的实例化通过构造方法创建bean 的实例默认是无参构造
给bean 的属性赋值调用 set 方法
执行初始化的方法需要配置初始化方法
得到完整的bean 对象，这时的bean 对象才能够使用
销毁bean 需要配置销毁的方法

要考虑 bean 的后置处理器 BeanPostProcessor

创建一个类实现BeanPostProcessor 重写他的两个方法

public class MyBeanPost implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在bean 初始化之前执行");

        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

        System.out.println("在bean初始化之后执行");
        if(bean instanceof User){
            User user = (User) bean;
            user.setName("貂蝉");
            return user;
        }

        return bean;
    }
}

在配置文件配置这个 bean

 <bean id="myPostProcessor" class="com.qf.postprocessor.MyBeanPost"></bean>

总结：面试答案

bean 的实例化通过构造方法创建bean 的实例默认是无参构造
给bean 的属性赋值
把 bean 的实例传递给 bean的后置处理器的方法 postProcessBeforeInitialization
执行初始化的方法
把 bean 的实例传递给 bean的后置处理器的方法 postProcessAfterInitialization
得到完整的bean 对象，这时的bean 对象才能够使用
销毁bean 当容器关闭的时候调用销毁的方法

自定义初始化方法：添加“init-method”属性，Spring则会在创建对象之后，调用此方法。

自定义销毁方法：添加“destroy-method”属性，Spring则会在销毁对象之前，调用此方法。

销毁：工厂的close()方法被调用之后，Spring会毁掉所有已创建的单例对象。

分类：Singleton对象由Spring容器销毁、Prototype对象由JVM销毁。

12.3 生命周期注解

初始化注解、销毁注解

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@PostConstruct //初始化 
public void init(){
    System.out.println("init method executed");
}

@PreDestroy //销毁
public void destroy(){
    System.out.println("destroy method executed");
}

12.4 生命周期阶段

**单例bean：**singleton

随工厂启动创建 ==》构造方法 ==》 set方法(注入值) ==》 init(初始化) ==》构建完成 ==》随工厂关闭销毁

**多例bean：**prototype

被使用时创建 ==》构造方法 ==》 set方法(注入值) ==》 init(初始化) ==》构建完成 ==》JVM垃圾回收销毁

十三、代理设计模式

13.1 概念

将核心功能与辅助功能（事务、日志、性能监控代码）分离，达到核心业务功能更纯粹、辅助业务功能可复用。

功能分离

13.2 静态代理设计模式

通过代理类的对象，为原始类的对象（目标类的对象）添加辅助功能，更容易更换代理实现类、利于维护。

静态代理

代理类 = 实现原始类相同接口 + 添加辅助功能 + 调用原始类的业务方法。
静态代理的问题
- 代理类数量过多，不利于项目的管理。
- 多个代理类的辅助功能代码冗余，修改时，维护性差。

House

public interface House {
    //出租
    public void rent();

}

HouseOwner

/**
 * @date 2023/4/21
 * @desc  房东  真实对象
 */
public class HouseOwner implements House{
    @Override
    public void rent() {
        System.out.println("签合同");
        System.out.println("收房租");
    }
}

Intermediary

/**
 * @date 2023/4/21
 * @desc  中介   是 代理对象
 */
public class Intermediary implements House{

    // 代理哪个真实对象
    private HouseOwner houseOwner;

    public Intermediary() {
    }

    public Intermediary(HouseOwner houseOwner) {
        this.houseOwner = houseOwner;
    }

    @Override
    public void rent() {
        System.out.println("发布租房信息");
        System.out.println("带租户看房");

        //调真实对象的方法   也就是被代理的对象
        houseOwner.rent();

        System.out.println("维修");
        System.out.println("转租");
        System.out.println("收中介费");
        System.out.println("收违约金");

    }
}

Tenant

public class Tenant {

    public static void main(String[] args) {
        Tenant tenant = new Tenant();
        tenant.rentHouse();
    }

    private void rentHouse() {
        //房子的主人  房子的拥有者

        HouseOwner houseOwner = new HouseOwner();

        Intermediary intermediary = new Intermediary(houseOwner);

        intermediary.rent();
    }

}

13.3 动态代理设计模式

动态创建代理类的对象，为原始类的对象添加辅助功能。

13.3.1 JDK动态代理实现（基于接口）

代理对象和真实对象的关系像是兄弟代理对象对真实对象进行增强

个人代码

接口

public interface Marry {

    public void marry();


    public int money();

}

真实对象

public class You implements Marry {
    @Override
    public void marry() {
        System.out.println("终身大事");
    }

    @Override
    public int money() {
        int num = 10;
        System.out.println("花了"+num+"块钱");
        return num;
    }
}

封装的一个工具类

public class JdkProxy implements InvocationHandler {
    private Object target;   //真实对象   被代理的对象

    //把真实对象传进来   返回代理对象
    public Object getProxy(Object target){
        this.target = target;
       return 	Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }


    //对真实对象的功能增强
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("准备工作");

        Object result = method.invoke(target, args);

        System.out.println("收尾工作");

        if(target instanceof Marry){
            return 100;
        }
        return result;
    }
}

测试

public class TestJdkProxy {
    public static void main(String[] args) {
        //真实对象
        You you = new You();

        JdkProxy jdkProxy = new JdkProxy();

        //得到代理对象
        Marry proxy = (Marry) jdkProxy.getProxy(you);

        //调用代理对象的方法
        proxy.marry();

        int money = proxy.money();

        System.out.println(money);
    }
}

13.3.2 CGlib动态代理实现（基于继承）

代理对象和真实对象的关系就像是父子

final OrderService os = new OrderServiceImpl();
Enhancer cnh = new Enhancer();//1.创建字节码曾强对象
enh.setSuperclass(os.getClass());//2.设置父类（等价于实现原始类接口）
enh.setCallback(new InvocationHandler(){//3.设置回调函数（额外功能代码）
    @Override
    public Object invoke(Object proxy , Method method, Object[] args) throws Throwable{
        System.out.println("start...");
        Object ret = method.invoke(os,args);
        System.out.println("end...");
        return ret;
    }
});
OrderService proxy = (OrderService)enh.create();//4.创建动态代理类
proxy,createOrder();

个人代码

真实对象

public class You {
    public void marry() {
        System.out.println("终身大事");
    }

    public int money() {
        int num = 10;
        System.out.println("花了"+num+"块钱");
        return num;
    }

}

工具类封装得到代理对象的方法和回调方法

package com.qf.proxy.cglibproxy;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.InvocationHandler;

import java.lang.reflect.Method;


public class CglibProxy implements InvocationHandler {
    //真实对象
    private Object target;

    //传入真实对象 得到代理对象
    public Object getProxy(Object target){
        this.target = target;
        Enhancer enhancer = new Enhancer();//1.创建字节码曾强对象
        enhancer.setSuperclass(target.getClass());//2.设置父类（等价于实现原始类接口）
        //设置回调函数
        enhancer.setCallback(this);
        //返回代理对象
        return enhancer.create();
    }



    //真实对象方法增强
    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
        System.out.println("准备工作");

        Object result = method.invoke(target, objects);
        System.out.println("收尾工作");
        return result;
    }
}

测试

package com.qf.proxy.cglibproxy;

public class TestCglibProxy {

    public static void main(String[] args) {
        //真实对象
        You you = new You();
        //工具类对象
        CglibProxy cglibProxy = new CglibProxy();
        //得到代理对象
        You proxy = (You) cglibProxy.getProxy(you);

        proxy.marry();
    }
}

十四、面向切面编程【`重点`】

14.1 概念

AOP（Aspect Oriented Programming），即面向切面编程，利用一种称为"横切"的技术，剖开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

什么是AOP ？

1.面向切面编程利用AOP 可以对业务逻辑的各个部分进行隔离从而使业务逻辑的各部分之间耦合度降低，提高程序的可重用性，提好了开发效率，通俗的讲可以实现不修改源代码的方式，在核心业务里面添加新的功能

AOP 底层的原理就是动态代理，真正干活的 bean 是代理bean , 代理bean 对真实bean 功能增强

14.2 AOP开发术语

连接点(Joinpoint)：连接点是程序类中客观存在的方法，可被Spring拦截并切入内容。

说白了类中的哪些方法可以被增强这些方法就称为是连接点

切入点(Pointcut)：被Spring切入连接点。

真正被增强的方法称为切入点

通知、增强(Advice)：可以为切入点添加额外功能，分为：前置通知、后置通知、异常通知、环绕通知，最终通知等。

实际增强的逻辑部分称为通知（增强）

目标对象(Target)：代理的目标对象真实对象

引介(Introduction)：一种特殊的增强，可在运行期为类动态添加Field和Method。

织入(Weaving)：把通知应用到具体的类，进而创建新的代理类的过程。

代理(Proxy)：被AOP织入通知后，产生的结果类。

切面(Aspect)：由切点和通知组成，将横切逻辑织入切面所指定的连接点中。是一个动作把通知应用到切入点的过程

切点：真正要被增强的方法

通知：增强的业务代码

切面：切点 + 通知

14.3 作用

Spring的AOP编程即是通过动态代理类为原始类的方法添加辅助功能。

14.4 环境搭建

引入AOP相关依赖

   <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-aspectsartifactId>
            <version>5.2.9.RELEASEversion>
        dependency>

spring-context.xml引入AOP命名空间


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       ">
    
    
beans>

14.5 开发流程

定义原始类

package com.glls.java2301.service;

/**
 * @date 2023/4/21
 * @desc
 */
public interface UserService {

    public void save();

}

public class UserServiceImpl implements UserService {
    @Override
    public void save() {
        //增删改 的代码 执行之前  需要开启事务
        System.out.println("save user");
        //增删改 的代码 执行之后 需要提交  或者  回滚事务
    }
}

下面是基于 Schema-based 的 aop实现方式得认识

四种通知

MyBeforeAdvice 前置通知

AfterReturningAdvice 后置返回通知

注意 Schema-based 没有最终通知

MethodInterceptor 环绕通知

ThrowsAdvice 异常通知

定义通知类（添加额外功能）

package com.glls.java2301.advice;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

/**
 * @date 2023/4/21
 * @desc 基于  Schema-based  的 前置通知
 */
public class MyBeforeAdvice implements MethodBeforeAdvice {

    /**
     * @param method   切点的方法对象
     * @param args  切点的方法参数
     * @param target 被代理的对象
     *
     * */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
            System.out.println("前置通知");
            System.out.println("开启事务");
    }
}

定义bean标签


    <bean id="userService" class="com.glls.java2301.service.impl.UserServiceImpl">bean>



    <bean id="myBeforeAdvice" class="com.glls.java2301.advice.MyBeforeAdvice">bean>

定义切入点（PointCut）

形成切面（Aspect）


    <aop:config>
        <aop:pointcut id="point1" expression="execution(* com.glls.java2301.service.impl.UserServiceImpl.save(..))"/>

    aop:config>


    <aop:config>
   

        <aop:advisor advice-ref="myBeforeAdvice" pointcut-ref="point1" >aop:advisor>
    aop:config>

下面是基于 AspectJ 的 AOP 实现方式

方式1 基于 xml 的配置

创建通知类

package com.qf.aspectjadvice;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * @ClassName : MyAspectJAdvice

 * @Description :   AspectJ 的 通知类  无需实现接口
 */
public class MyAspectJAdvice {

    public void mybefore(){
        System.out.println("aspectj的前置通知");
    }

    public void myafter(){
        System.out.println("aspectj的后置通知");
    }

    public Object myaround(ProceedingJoinPoint p) throws Throwable {
        System.out.println("环绕前置");
        Object result = p.proceed();
        System.out.println("环绕后置");

        return  result;
    }
}

xml 配置


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    
    
    <context:component-scan base-package="com.qf">context:component-scan>

    

    <bean id="myaspectj" class="com.qf.aspectjadvice.MyAspectJAdvice">bean>

    <aop:config>

        <aop:aspect ref="myaspectj">
            <aop:pointcut id="aspectjpoint1" expression="execution(* save(..))"/>
        aop:aspect>

        <aop:aspect ref="myaspectj">
            <aop:pointcut id="aspectjpoint2" expression="execution(* com.qf.service.impl.OrderServiceImpl.save(..))"/>
        aop:aspect>

        <aop:aspect ref="myaspectj">

            <aop:before method="mybefore" pointcut-ref="aspectjpoint1">aop:before>

            <aop:after method="myafter" pointcut-ref="aspectjpoint1">aop:after>

            <aop:around method="myaround" pointcut-ref="aspectjpoint2">aop:around>
        aop:aspect>
    aop:config>


beans>

测试：

 @Test
    public void test2(){
        // 基于 Aspectj  的 xml 的  AOP  了解   看得懂
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans2.xml");

        UserService userService = applicationContext.getBean("userService", UserService.class);
        OrderService orderService = applicationContext.getBean("orderService", OrderService.class);

        userService.save();

        //userService.delete(1);
        Order order = new Order(1, "订单描述");
        //orderService.save(order);
    }

方式2 aspectj 基于注解的aop 实现 要求掌握

配置文件


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    
    
    <context:component-scan base-package="com.qf">context:component-scan>

    
    <aop:aspectj-autoproxy>aop:aspectj-autoproxy>


beans>

通知类

package com.glls.java2301.aspectjannoadvice;

import org.aopalliance.intercept.Joinpoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @date 2023/4/23
 * @desc  基于AspectJ的  注解形式的aop实现   要求 熟练掌握
 *
 * 这种方式 很简洁  ，只需要在当前类  写通知 和 切点元素 ，无需在 配置文件中 进行繁琐的配置
 *
 */
@Aspect    // 当前类 是一个 切面类
@Component    // 这个注解 表明 当前类的对象 是spring 管理的bean
public class AspectJAnnoAdvice {

    // @Before 表示前置通知
    //@Before("execution(* save(..))")
    //public void before(){
    //    System.out.println("基于aspectj注解形式的前置通知，要求大家掌握");
    //}


    @Pointcut(value = "execution(* save(..))")
    public void point1(){
        System.out.println("切点1");
    }


    @Pointcut(value = "execution(* delete(..))")
    public void point2(){
        System.out.println("切点2");
    }


    @Before("point1()")
    public void before(){
        System.out.println("基于aspectj注解形式的前置通知，要求大家掌握");
    }
    @After("point2()")
    public void after(){
        System.out.println("基于aspectj注解形式的后置通知，要求大家掌握");
    }
    @Around("point2()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前置");

        Object result = joinPoint.proceed();
        System.out.println("环绕后置");
        System.out.println(result);
        return result;
    }


    @AfterReturning("point2()")
    public void afterreturning(){
        //切点正常执行 没有异常 才会执行 最终通知
        System.out.println("最终通知");
    }

    @AfterThrowing(value = "point2()",throwing = "ex")
    public void afterthrowing(Exception ex){

        System.out.println("异常通知");
        System.out.println("异常信息："+ ex.getMessage());
    }

}

测试效果

14.6 AOP小结

通过AOP提供的编码流程，更便利的定制切面，更方便的定制了动态代理。

进而彻底解决了辅助功能冗余的问题；

业务类中职责单一性得到更好保障；

辅助功能也有很好的复用性。

14.7 通知类【可选】

定义通知类，达到通知效果

前置通知：MethodBeforeAdvice

后置通知：AfterAdvice

后置通知：AfterReturningAdvice //有异常不执行，方法会因异常而结束，无返回值

异常通知：ThrowsAdvice

环绕通知：MethodInterceptor

没有必要把通知的执行顺序记得非常精确因为 spring 新版本 5 和之前的旧版本通知的执行顺序不一样

14.8 通配切入点

根据表达式通配切入点


<aop:pointcut id="myPointCut" expression="execution(* *(com.qf.aaron.aop.basic.User))" />

<aop:pointcut id="myPointCut" expression="execution(* save())" />

<aop:pointcut id="myPointCut" expression="execution(* save(..))" />

<aop:pointcut id="myPointCut" expression="execution(com.qf.aaron.aop.basic.User *(..))" />

<aop:pointcut id="myPointCut" expression="execution(* com.qf.aaron.aop.basic.UserServiceImpl.*(..))" />

<aop:pointcut id="myPointCut" expression="execution(* com.qf.aaron.aop.basic.*.*(..))" />

<aop:pointcut id="myPointCut" expression="execution(* com.qf.aaron.aop..*.*(..))" />

切入点表达式：expression 知道对哪个类的那个方法进行增强

语法结构： execution([权限修饰符] [返回值类型] [类全路径] [方法名称] （[参数列表])

14.9 JDK和CGLIB选择

spring底层，包含了jdk代理和cglib代理两种动态代理生成机制

基本规则是：目标业务类如果有接口则用JDK代理，没有接口则用CGLib代理

class DefaultAopProxyFactory{
    // 该方法中明确定义了 JDK代理和CGLib代理的选取规则
    // 基本规则是：目标业务类如果有接口则用JDK代理，没有接口则用CGLib代理
    public AopProxy createAopProxy(){...}
}

14.10 后处理器

spring中定义了很多后处理器；

每个bean在创建完成之前，都会有一个后处理过程，即再加工，对bean做出相关改变和调整；

spring-AOP中，就有一个专门的后处理器，负责通过原始业务组件(Service),再加工得到一个代理组件。

常用后处理器
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-flEGgsYu-1683019927709)(https://gllspictures.oss-cn-beijing.aliyuncs.com/img/系统后处理器.jpg)]

14.10.1 后处理器定义

/**
 * 定义bean后处理器
 * 作用：在bean的创建之后，进行再加工
 */
public class MyBeanPostProcessor implements BeanPostProcessor{

    /**
     * 在bean的init方法之前执行
     * @param bean  原始的bean对象
     * @param beanName
     * @return
     * @throws BeansException
     */
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("后处理器 在init之前执行~~~"+bean.getClass());
        return bean;
    }
	/**
     * 在bean的init方法之后执行
     * @param bean  postProcessBeforeInitialization返回的bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("后处理器 在init之后执行~~~"+bean.getClass());
        return bean;// 此处的返回是 getBean() 最终的返回值
    }
}

14.10.2 配置后处理器


<bean class="com.qianfeng.beanpostprocessor.MyBeanPostProcessor">bean>

14.10.3 bean生命周期

构造》注入属性满足依赖》后处理器前置过程》初始化》后处理器后置过程》返回》销毁

记住记住记住记住记住记住

1.如果是单例 bean ，随着容器的创建而创建即实例化，多例bean 是获取的时候实例化

2.属性注入

3.后处理器前置过程即在初始化方法之前执行的方法 postProcessBeforeInitialization

4.初始化方法

5.后处理器后置过程即在初始化方法之后执行的方法 postProcessAfterInitialization aop动态代理就在这一步

6.得到最终的 bean

7.销毁

14.10.4 动态代理源码(了解)

// AbstractAutoProxyCreator是 AspectJAwareAdvisorAutoProxyCreator的父类
// 该后处理器类中的 wrapIfNecessary方法即动态代理生成过程
AbstractAutoProxyCreator#postProcessAfterInitialization(Object bean, String beanName){
    if (!this.earlyProxyReferences.contains(cacheKey)) {
        // 开始动态定制代理
        return wrapIfNecessary(bean, beanName, cacheKey);
   	}
}

十五、Spring + MyBatis【`重点`】

15.1 我的整合步骤

1.添加依赖




  4.0.0

  com.glls.java2301
  sm
  1.0-SNAPSHOT
  war

  sm Maven Webapp
  
  http://www.example.com

  
    UTF-8
    1.8
    1.8
  

  
    
    
      org.springframework
      spring-context
      5.2.9.RELEASE
    

    
    
      org.springframework
      spring-aspects
      5.2.9.RELEASE
    


    
      junit
      junit
      4.12
    

    
      org.projectlombok
      lombok
      1.18.12
    


    
      mysql
      mysql-connector-java
      8.0.18
    
    
    
      org.mybatis
      mybatis
      3.4.6
    

    
    
      org.springframework
      spring-jdbc
      5.2.9.RELEASE
    

    
    
      org.mybatis
      mybatis-spring
      1.3.2
    

    
    
      com.alibaba
      druid
      1.1.16
    


    
    
      org.springframework
      spring-web
      5.2.9.RELEASE
    

    
      javax.servlet
      javax.servlet-api
      3.1.0
      provided
    

    
      javax.servlet
      jsp-api
      2.0
      provided
    

    
      javax.servlet
      jstl
      1.2
    





    
    
      org.slf4j
      slf4j-api
      1.7.25
    
    
      ch.qos.logback
      logback-core
      1.2.3
    
    
      ch.qos.logback
      logback-classic
      1.2.3
    
    
      log4j
      log4j
      1.2.17
    
    
      org.logback-extensions
      logback-ext-spring
      0.1.4
    

  

  
    sm
    
      
        
          maven-clean-plugin
          3.1.0
        
        
        
          maven-resources-plugin
          3.0.2
        
        
          maven-compiler-plugin
          3.8.0
        
        
          maven-surefire-plugin
          2.22.1
        
        
          maven-war-plugin
          3.2.2
        
        
          maven-install-plugin
          2.5.2
        
        
          maven-deploy-plugin
          2.8.2
        
      
    


    
    
      
        src/main/java
        
          **/*.xml
        
      
      
        src/main/resources
        
          **/*.xml
          **/*.properties
          **/*.ini

15.2.相关配置文件

准备数据源配置文件 db.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm?characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
jdbc.username=root
jdbc.password=123456

applicationContext.xml


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    
    
    <context:component-scan base-package="com.glls.java2301">context:component-scan>

    
    <aop:aspectj-autoproxy>aop:aspectj-autoproxy>

    
    <context:property-placeholder location="classpath:db.properties" />
	
    
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>


        
        <property name="maxWait" value="60000"/>

        
        <property name="timeBetweenEvictionRunsMillis" value="60000"/>

        
        <property name="minEvictableIdleTimeMillis" value="300000"/>
    bean>

    
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        
        <property name="dataSource" ref="dataSource">property>
        
        <property name="configLocation" value="classpath:mybatis-config.xml">property>
    bean>
    
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        
        <property name="basePackage" value="com.glls.java2301.mapper">property>

        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory">property>
    bean>

beans>

mybatis的配置文件


DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        
        <package name="com.glls.java2301.pojo" />
    typeAliases>
    <mappers>
        
        <package name="com.glls.java2301.mapper"/>
    mappers>
configuration>

15.3 整合 logback 日志

添加依赖

 
    
      org.slf4j
      slf4j-api
      1.7.25
    
    
      ch.qos.logback
      logback-core
      1.2.3
    
    
      ch.qos.logback
      logback-classic
      1.2.3
    
    
      log4j
      log4j
      1.2.17
    
    
      org.logback-extensions
      logback-ext-spring
      0.1.4

添加日志的配置文件 logback.xml


<configuration>
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <Target>System.outTarget>
        <Encoding>UTF-8Encoding>
        <encoder>
            <pattern>%d{yyyy-MM-dd_HH:mm:ss.SSS} %5p [%t] [%c{1}]:%L - %m%n
            pattern>
        encoder>
    appender>
    <appender name="logfile"
              class="ch.qos.logback.core.rolling.RollingFileAppender">
        <Encoding>UTF-8Encoding>
        <encoder>
            <pattern>%d %p [%t] [%c]:%L - %m%npattern>
        encoder>
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>DEBUGlevel>
        filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>log/%d{yyyy-MM-dd-HH'.log'}fileNamePattern>
        rollingPolicy>
    appender>
    <logger name="org.springframework" level="WARN" />
    <logger name="org.springframework.remoting" level="WARN" />
    <logger name="org.springframework.scheduling.quartz" level="WARN" />
    <logger name="org.springframework.data.jpa" level="DEBUG" />
    <logger name="org.cometd" level="WARN" />
    <logger name="ch.qos.logback" level="WARN" />
    <logger name="com.springapp.mvc" level="DEBUG" />
    <logger name="com.glls.java2301.mapper" level="DEBUG">logger>
    

    <root level="ERROR">
        <appender-ref ref="stdout" />
        <appender-ref ref="logfile" />
    root>
configuration>

配置到 web.xml 中通过监听器读取日志的配置文件

    
    <context-param>
        <param-name>logbackConfigLocationparam-name>
        <param-value>classpath:logback.xmlparam-value>
    context-param>
    <listener>
        <listener-class>ch.qos.logback.ext.spring.web.LogbackConfigListenerlistener-class>
    listener>

整合 servlet ，后期换成 springmvc ,当前先用servlet

1.添加依赖

  
    
      org.springframework
      spring-web
      5.2.9.RELEASE
    

    
      javax.servlet
      javax.servlet-api
      3.1.0
      provided
    

    
      javax.servlet
      jsp-api
      2.0
      provided
    

    
      javax.servlet
      jstl
      1.2

2.在web.xml 中添加一个监听器用于读取spring 的配置文件创建容器

 <context-param>
        <param-name>contextConfigLocationparam-name>
        <param-value>classpath:applicationContext.xmlparam-value>
    context-param>
    
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
    listener>

创建servlet 在 servlet中得到容器对象再通过容器对象来得到 service bean

package com.qf.web;

import com.qf.pojo.User;
import com.qf.service.UserService;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @ClassName : LoginServlet
 * @Author : glls
 * @Date: 2021/8/10 14:43
 * @Description :
 */
@WebServlet("/login")
public class LoginServlet extends HttpServlet {

    private UserService userService;

    @Override
    public void init() throws ServletException {
        WebApplicationContext applicationContext = WebApplicationContextUtils.getRequiredWebApplicationContext(getServletContext());

        userService = applicationContext.getBean("userService", UserService.class);


    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String username = req.getParameter("username");

        String password = req.getParameter("password");

        //有了spring 管理 bean ,就不要再自己new 对象了 ，所以
        //从容器 把 userService 取出来
        User user = new User();
        user.setName(username);
        user.setPassword(password);
        User result = userService.login(user);
        System.out.println(result);
    }
}

十六、事务【`重点`】

什么是事务？

事务是数据库操作的基本单元，逻辑上的一组操作，要么都成功，要么都失败，也就是说只有一组操作中有一个失败了，那么这组操作都失败

举个例子

wsc转账500给wjl

update t_account set money = money-500 where accountid = 1 wsc 的账户减500

update t_account set money = money+500 where accountid=2 wjl的账户加 500
事务的特性 ACID

A atomicity 原子性一组操作整体不可拆分要么都成功要么都失败

C consistency 一致性数据在事务的前后，业务整体一致

I isolation 隔离性事务之间互相隔离

D durability 持久性一旦事务执行成功数据一定会落盘在数据库

3.准备事务的环境

账户表

service 定义转账方法

    //转账操作
    @Override
    public void transferMoney(int from, int to, double money) {
        //from 给   to 转了  money
        //一个账户 扣钱
        accountMapper.reduceMoney(from,money);
        //模拟一个异常
        int i = 5/0;
        //一个账户加钱
        accountMapper.addMOney(to,money);
    }

dao

    @Update("update t_account set money= money - #{money} where userid= #{from} ")
    void reduceMoney(@Param("from") int from,@Param("money") double money);

    @Update("update t_account set money = money + #{money} where userid = #{to} ")
    void addMOney(@Param("to")int to, @Param("money") double money);

转账过程中模拟异常，出现一个账户扣钱了，另一个账户却没有加钱数据不一致问题怎么解决？

使用事务进行解决

spring提供了事务的解决方案底层原理是 AOP

基于注解的方案掌握
基于xml配置文件的方式了解

16.1咱们先来看基于xml 首先在是spring 的配置文件配置事务管理器

第一步配置DataSourceTransactionManager

事务管理器，其中持有DataSource，可以控制事务功能（commit,rollback等）。


<bean id="tx" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource">property>
bean>

注意：DataSourceTransactionManager 和 SqlSessionFactoryBean 要注入同一个DataSource的Bean，否则事务控制失败!!!

第二步配置事务通知

基于事务管理器，进一步定制，生成一个额外功能：Advice。

此Advice可以切入任何需要事务的方法，通过事务管理器为方法控制事务。

<tx:advice id="txadvice" transaction-manager="tx">
	<tx:attributes>
        
        
        <tx:method name="*User" rollback-for="Exception"/>
        
        <tx:method name="query*" propagation="SUPPORTS"/>
        
        <tx:method name="*"/>
    tx:attributes>
tx:advice>

第三步配置事务切面

  
    <aop:config>
        
        <aop:pointcut id="txpoint" expression="execution(* com.glls.java2301.service.impl.AccountServiceImpl.*(..))"/>
        
        <aop:advisor advice-ref="txadvice" pointcut-ref="txpoint">aop:advisor>
    aop:config>

第四步进行测试

16.2 基于注解的事务配置

在 applicationContext2.xml 中进行基于注解的事务配置

第一步还是配置事务管理器


    
    <bean id="tx" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource">property>
    bean>

第二步开启事务的注解

<!--  2.  开启事务的注解-->
    <tx:annotation-driven transaction-manager="tx"/>

第三步在需要事务的方法上使用注解

 @Transactional
    public void transferMoney(int from, int to, double money) {
        ......

第四步测试

16.3 事务属性

16.3.1 隔离级别

16.3.1.1 概念

isolation 隔离级别

名称	描述
default	(默认值）（采用数据库的默认的设置) （建议）
read-uncommited	读未提交
read-commited	读已提交（Oracle数据库默认的隔离级别）
repeatable-read	可重复读（MySQL数据库默认的隔离级别）
serialized-read	序列化读

隔离级别由低到高为：read-uncommited < read-commited < repeatable-read < serialized-read

16.3.1.2 特性

安全性：级别越高，多事务并发时，越安全。因为共享的数据越来越少，事务间彼此干扰减少。

并发性：级别越高，多事务并发时，并发越差。因为共享的数据越来越少，事务间阻塞情况增多。

16.3.1.3 并发问题

事务并发时的安全问题

问题	描述
脏读	一个事务读取到另一个事务还未提交的数据。大于等于 read-commited 可防止
不可重复读	一个事务内多次读取一行数据的相同内容，其结果不一致。大于等于 repeatable-read 可防止
幻影读	幻读，并不是说两次读取获取的结果集不同，幻读侧重的方面是某一次的 select 操作得到的结果所表征的数据状态无法支撑后续的业务操作。更为具体一些：select 某记录是否存在，不存在，准备插入此记录，但执行 insert 时发现此记录已存在，无法插入，此时就发生了幻读。mysql 幻读的详解、实例及解决办法 - SegmentFault 思否

SELECT @@tx_isolation;       --  查看 当前 隔离级别

SHOW VARIABLES LIKE 'autocommit'  --  查看自动提交 是否开启

SET autocommit=0;    --  关闭自动提交 
 
SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;   --  设置 读未提交 隔离级别    会出现脏读 不可重复度 幻读
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;   --  设置 读已提交 隔离级别  可出现 不可重复度 幻读
SET SESSION TRANSACTION ISOLATION LEVEL READ REPEATABLE READ;   --  设置 可重复度 隔离级别  可出现幻读

#步骤1
START TRANSACTION;  -- 开启事务

UPDATE t_order  SET productNum = 3 WHERE userId = 10;

#步骤3 
-- 提交  或者  回滚
COMMIT;     -- 提交事务
ROLLBACK;   -- 回滚事务

    //@Transactional(isolation = Isolation.SERIALIZABLE)  // 序列化读的隔离级别 可以避免脏读  不可重复读  幻读
    @Transactional(isolation = Isolation.REPEATABLE_READ)  // 可重复读的隔离级别 可以避免脏读 不可重复读   但是会出现 幻读
    //@Transactional(isolation = Isolation.READ_COMMITTED)  // 读已提交的隔离级别 可以避免脏读  但是会出现 不可重复读  幻读
    //@Transactional(isolation = Isolation.READ_UNCOMMITTED)  // 读未提交的隔离级别 会出现脏读  不可重复读  幻读
    public List<Order> findOrderById(Integer id) {

        List<Order> list1 = orderMapper.findOrderByUserId(id);
        System.out.println(list1);

        System.out.println("----------------------");

        List<Order> list2 = orderMapper.findOrderByUserId(id);
        return list1;
    }

16.3.2 传播行为

propagation传播行为

当涉及到事务嵌套（Service调用Service）时，可以设置：

SUPPORTS = 不存在外部事务，则不开启新事务；存在外部事务，则合并到外部事务中。（适合查询）

REQUIRED = 不存在外部事务，则开启新事务；存在外部事务，则合并到外部事务中。 (默认值)（适合增删改）

参考资料：事务隔离级别和传播行为_Spring事务的传播行为和隔离级别_weixin_39604685的博客-CSDN博客

orderService

@Override
    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
    public Integer addOrder(Order order) throws ClassNotFoundException {
        //添加订单
       int result =  orderMapper.addOrder(order);
       //int i = 5/0;
       //Class.forName("java.lang.String2");  // 默认  对检查时异常 不回滚

        // 扣减库存
        //int result2 = updateStock(order);
        //stockMapper.updateStock(order);
        int result2 = stockService.updateStock(order);
        // 扣减账户
        //int result3 = updateAccount(order);
        //accountMapper.updateAccount(order);
        int result3 = accountService.updateAccount(order);

        return result3;
    }

stockService

 @Override
    //@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
    public int updateStock(Order order) {
        return stockMapper.updateStock(order);
    }

accountService

    @Override
    //@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
    public int updateAccount(Order order) {
        return accountMapper.updateAccount(order);
    }

16.3.3 读写性

readonly 读写性

true：只读，可提高查询效率。(适合查询)

false：可读可写。 (默认值)（适合增删改）

16.3.4 事务超时

timeout事务超时时间

当前事务所需操作的数据被其他事务占用，则等待。

100：自定义等待时间100（秒）。

-1：由数据库指定等待时间，默认值。（建议）

16.3.5 事务回滚

rollback-for 回滚属性

如果事务中抛出 RuntimeException,则自动回滚

如果事务中抛出 CheckException(非运行时异常 Exception)，不会自动回滚，而是默认提交事务

处理方案 : 将CheckException转换成RuntimException上抛，或设置 rollback-for=“Exception.class”

十七、注解开发

1.什么是注解

（1）注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值…)

（2）使用注解，注解作用在类上面，方法上面，属性上面

（3）使用注解目的：简化 xml 配置

2.spring针对Bean管理创建对象提供的注解

（1）@Component

（2）@Service

（3）@Controller

（4）@Repository

上面四个注解功能是一样的，都可以用来创建 bean 实例

3.基于注解方式实现对象创建

1.需要aop 依赖的支持 spring-aop

2.开启组件扫描

1 如果扫描多个包，多个包使用逗号隔开 

2 扫描包上层目录


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
	
       <context:component-scan base-package="com.glls.java2301">context:component-scan>

    
beans>

3.创建类在类上添加创建bean 的注解

//在注解里面 value 属性值可以省略不写，

//默认值是类名称，首字母小写

//UserService – userService

4.开启组件扫描细节配置

 

  

    
    <context:component-scan base-package="com.glls" >
    context:component-scan>

5.基于注解的方式实现属性注入

（1）@Autowired：先根据类型注入再根据名字注入

第一步把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解

第二步在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解

@Service 

public class UserService { 

	//定义 dao 类型属性 

	//不需要添加 set 方法 

	//添加注入属性注解 

	@Autowired  

	private UserDao userDao; 
    

	public void add() { 

		System.out.println("service add......."); 

	    userDao.add(); 

	} 

}

（2）@Qualifier：根据名称进行注入

这个@Qualifier 注解的使用，和上面@Autowired 一起使用

//定义 dao 类型属性 

//不需要添加 set 方法

//添加注入属性注解 

@Autowired //根据类型进行注入 

@Qualifier(value = "userDaoImpl1") 

//根据名称进行注入 

private UserDao userDao;

（3）@Resource：先根据名字注入再根据类型注入

//@Resource //根据类型进行注入 

@Resource(name = "userDaoImpl1") //根据名称进行注入 

private UserDao userDao;

（4）@Value：注入普通类型属性

@Value(value = "abc") 

private String name;

6、完全注解开发

（1）创建配置类，替代 xml 配置文件

@Configuration //作为配置类，替代 xml 配置文件 

@ComponentScan(basePackages = {"com.glls"}) 

public class SpringConfig { 

}

（2）编写测试类

@Test 

public void testService2() { 

//加载配置类 

ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class); 

UserService userService = context.getBean("userService",  UserService.class); 

System.out.println(userService); 

userService.add(); 

}

17.1 声明bean

用于替换自建类型组件的标签；可以更快速的声明bean

@Service 业务类专用
@Repository dao实现类专用
@Controller web层专用

@Component 通用

@Scope 用户控制bean的创建模式

// @Service说明 此类是一个业务类，需要将此类纳入工厂  等价替换掉 
// @Service默认beanId == 首字母小写的类名"userServiceImpl"
// @Service("userService") 自定义beanId为"userService"
@Service //声明bean，且id="userServiceImpl"
@Scope("singleton") //声明创建模式，默认为单例模式 ；@Scope("prototype")即可设置为多例模式
public class UserServiceImpl implements UserService {
 	...   
}

17.2 注入(DI)

用于完成bean中属性值的注入

@Autowired 基于类型自动注入先根据类型注入如果找到多个再根据名称注入

@Resource 基于名称自动注入先根据名称注入如果根据名称没找到则根据类型找根据类型找到多个则报错找到一个则注入

@Qualifier(“userDAO”) 限定要自动注入的bean的id，一般和@Autowired联用

@Value 注入简单类型数据 (jdk8种+String)

@Service
public class UserServiceImpl implements UserService {
    
    @Autowired //注入类型为UserDAO的bean
    @Qualifier("userDAO2") //如果有多个类型为UserDAO的bean，可以用此注解从中挑选一个
    private UserDAO userDAO;
}

@Service
public class UserServiceImpl implements UserService {
    
	@Resource("userDAO3") //注入id=“userDAO3”的bean
    private UserDAO userDAO;
    /*
    @Resource //注入id=“userDAO”的bean
    private UserDAO userDAO;
    */
}

public class XX{
    @Value("100") //注入数字
    private Integer id;
    @Value("shine") //注入String
	private String name;
}

小结：

四个创建bean的注解： @Controller @Service @Repository @Component

注入依赖bean的注解：（@Autowired 搭配 @Qualifier 指定名字） @Resource

注入普通属性的注解：@Value

标识配置类的注解：@Configuration

指定扫描包的注解 : @ComponentScan(basePackages = {“com.glls.java2301”})

指定优先级的注解：@Primary

指定初始化方法的注解：@PostConstruct

指定销毁bean 的时候调用的方法：@PreDestroy

17.5 AOP开发

17.5.1 注解使用

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect // 声明此类是一个切面类：会包含切入点(pointcut)和通知(advice)
@Component //声明组件，进入工厂
public class MyAspect {
    // 定义切入点
    @Pointcut("execution(* com.qf.spring.service.UserServiceImpl.*(..))")
    public void pc(){}
    
    @Before("pc()") // 前置通知
    public void mybefore(JoinPoint a) {
        System.out.println("target:"+a.getTarget());
        System.out.println("args:"+a.getArgs());
        System.out.println("method's name:"+a.getSignature().getName());
        System.out.println("before~~~~");
    }

    @AfterReturning(value="pc()",returning="ret") // 后置通知
    public void myAfterReturning(JoinPoint a,Object ret){
        System.out.println("after~~~~:"+ret);
    }
    
    @Around("pc()") // 环绕通知
    public Object myInterceptor(ProceedingJoinPoint p) throws Throwable {
        System.out.println("interceptor1~~~~");
        Object ret = p.proceed();
        System.out.println("interceptor2~~~~");
        return ret;
    }
    
    @AfterThrowing(value="pc()",throwing="ex") // 异常通知
    public void myThrows(JoinPoint jp,Exception ex){
        System.out.println("throws");
        System.out.println("===="+ex.getMessage());
    }
}

17.5.2 配置


<aop:aspectj-autoproxy>aop:aspectj-autoproxy>

十八、集成JUnit

18.1 导入依赖

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-testartifactId>
    <version>4.3.6.RELEASEversion>
dependency>
<dependency>
    <groupId>junitgroupId>
    <artifactId>junitartifactId>
    <version>4.12version>
dependency>

18.2 编码

可以免去工厂的创建过程；

可以直接将要测试的组件注入到测试类。

集成Junit 5

    

    
      org.springframework
      spring-test
      5.2.9.RELEASE
    
    
      org.junit.jupiter
      junit-jupiter-api
      5.5.2
      test

测试类

@SpringJUnitConfig(locations = "classpath:applicationContext2.xml")
class OrderServiceImplTest {
    @Autowired
    private OrderService orderService;

    @Test
    void findOrderByUserId() {

        List<Order> orderByUserId = orderService.findOrderByUserId(10);

    }
}

总结：

十九、个人扩展

spring5 新的模块 webflux

1、SpringWebflux 介绍

（1）是 Spring5 添加新的模块，用于 web 开发的，功能和 SpringMVC 类似的，Webflux 使用当前一种比较流程响应式编程出现的框架。

（2）使用传统 web 框架，比如 SpringMVC，这些基于 Servlet 容器，Webflux 是一种异步非阻塞的框架，异步非阻塞的框架在 Servlet3.1 以后才支持，核心是基于 Reactor 的相关 API 实现的。

（3）解释什么是异步非阻塞

异步和同步
非阻塞和阻塞
上面都是针对对象不一样
异步和同步针对调用者，调用者发送请求，如果等着对方回应之后才去做其他事情就是同步，如果发送请求之后不等着对方回应就去做其他事情就是异步
阻塞和非阻塞针对被调用者，被调用者受到请求之后，做完请求任务之后才给出反馈就是阻塞，受到请求之后马上给出反馈然后再去做事情就是非阻塞

（4）Webflux 特点：

第一非阻塞式：在有限资源下，提高系统吞吐量和伸缩性，以 Reactor 为基础实现响应式编程

第二函数式编程：Spring5 框架基于 java8，Webflux 使用 Java8 函数式编程方式实现路由请求

（5）比较 SpringMVC

第一两个框架都可以使用注解方式，都运行在 Tomet 等容器中

第二 SpringMVC 采用命令式编程，Webflux 采用异步响应式编程

2、响应式编程（Java 实现）

（1）什么是响应式编程响应式编程是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。电子表格程序就是响应式编程的一个例子。单元格可以包含字面值或类似"=B1+C1"的公式，而包含公式的单元格的值会依据其他单元格的值的变化而变化。

3.手写spring 伪源码

创建maven工程无需添加任何依赖

在spring包下创建容器类 GllsApplicationContext

二十个人源码解析

个人学习

源码分析

ClassPathXmlApplicationContext：

super（parent）; 此时传进来的super 为空，在这个方法中调父类AbstractApplicationContext 构造方法创建了资源解析器

/**
Create a new AbstractApplicationContext with no parent.
*/
public AbstractApplicationContext() {
this.resourcePatternResolver = getResourcePatternResolver();
}

setConfigLocations(configLocations);

调父类构造

这个方法由子类重写

总结： resolvePath(String path) 方法做了什么事情？

1.实例化 Environment

2.解析传进来的 path

refresh（）方法

AbstractApplicationContext 类中

@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}
cationContext with no parent.
>*/
>public AbstractApplicationContext() {
>		this.resourcePatternResolver = getResourcePatternResolver();
>}





> setConfigLocations(configLocations);



<img src="https://gllspictures.oss-cn-beijing.aliyuncs.com/img/image-20210731170316872.png" alt="image-20210731170316872" style="zoom:80%;" />



>

<img src="https://gllspictures.oss-cn-beijing.aliyuncs.com/img/image-20210731170329424.png" alt="image-20210731170329424" style="zoom:80%;" />

>

<img src="https://gllspictures.oss-cn-beijing.aliyuncs.com/img/image-20210731170341320.png" alt="image-20210731170341320" style="zoom:80%;" />



>

<img src="https://gllspictures.oss-cn-beijing.aliyuncs.com/img/image-20210731170621745.png" alt="image-20210731170621745" style="zoom:80%;" />

[外链图片转存中...(img-18iiTbpW-1683019925567)]



> 调父类构造

[外链图片转存中...(img-ffaW8PFC-1683019925567)]



>

<img src="https://gllspictures.oss-cn-beijing.aliyuncs.com/img/image-20210731170751050.png" alt="image-20210731170751050" style="zoom:80%;" />

> 这个方法由子类重写



<img src="https://gllspictures.oss-cn-beijing.aliyuncs.com/img/image-20210731170819152.png" alt="image-20210731170819152" style="zoom:80%;" />





>



<img src="https://gllspictures.oss-cn-beijing.aliyuncs.com/img/image-20210731170858551.png" alt="image-20210731170858551" style="zoom:80%;" />



>

<img src="https://gllspictures.oss-cn-beijing.aliyuncs.com/img/image-20210731170927146.png" alt="image-20210731170927146" style="zoom:80%;" />





总结： resolvePath(String path) 方法做了什么事情？

1.实例化 Environment  

2.解析传进来的  path 





------------------------------------

refresh（）方法

```java
AbstractApplicationContext 类中
```

~~~java
@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

你可能感兴趣的:(Java第三阶段,spring,java,后端)

Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器）编程经验分享开发工具服务器 ssh linux
目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
Low Power概念介绍-Voltage Area 飞奔的大虎
随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
SpringBlade dict-biz/list 接口 SQL 注入漏洞文章永久免费只为良心 oracle 数据库
SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
python语法——三目运算符 HappyRocking python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
spring如何整合druid连接池？惜.己 spring spring junit 数据库 java idea 后端 xml
目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
python怎么将png转为tif_png转tif weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
springboot+vue项目实战一-创建SpringBoot简单项目苹果酱0567 面试题汇总与解析 spring boot 后端 java 中间件开发语言
这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）跳房子的前端前端面试 javascript 开发语言 ecmascript
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
uniapp map组件自定义markers标记点以对_ uni-app学习记录 uni-app javascript 前端
需求是根据后端返回数据在地图上显示标记点，并且根据数据状态控制标记点颜色，标记点背景通过两张图片实现控制{{item.options.labelName}}exportdefault{data(){return{storeIndex:0,locaInfo:{longitude:120.445172,latitude:36.111387},markers:[//标点列表{id:1,//标记点idin
JAVA·一个简单的登录窗口 MortalTom java 开发语言学习
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
笋丁网页自动回复机器人V3.0.0免授权版源码希希分享软希网58soho_cn 源码资源笋丁网页自动回复机器人
笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
java工厂模式 3213213333332132 java 抽象工厂
工厂模式有 1、工厂方法 2、抽象工厂方法。下面我的实现是抽象工厂方法, 给所有具体的产品类定一个通用的接口。 package 工厂模式; /** * 航天飞行接口 * * @Description * @author FuJianyong * 2015-7-14下午02:42:05 */ public interface SpaceF
nginx频率限制+python测试 ronin47 nginx 频率 python
部分内容参考：http://www.abc3210.com/2013/web_04/82.shtml 首先说一下遇到这个问题是因为网站被攻击，阿里云报警，想到要限制一下访问频率，而不是限制ip（限制ip的方案稍后给出）。nginx连接资源被吃空返回状态码是502，添加本方案限制后返回599，与正常状态码区别开。步骤如下：
java线程和线程池的使用 dyy_gusi ThreadPool thread Runnable timer
java线程和线程池一、创建多线程的方式 java多线程很常见，如何使用多线程，如何创建线程，java中有两种方式，第一种是让自己的类实现Runnable接口，第二种是让自己的类继承Thread类。其实Thread类自己也是实现了Runnable接口。具体使用实例如下： 1、通过实现Runnable接口方式 1 2
Linux 171815164 linux
ubuntu kernel http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.1.2-unstable/ 安卓sdk代理 mirrors.neusoft.edu.cn 80 输入法和jdk sudo apt-get install fcitx su
Tomcat JDBC Connection Pool g21121 Connection
Tomcat7 抛弃了以往的DBCP 采用了新的Tomcat Jdbc Pool 作为数据库连接组件，事实上DBCP已经被Hibernate 所抛弃，因为他存在很多问题，诸如：更新缓慢，bug较多，编译问题，代码复杂等等。 Tomcat Jdbc P
敲代码的一点想法永夜-极光 java 随笔感想
入门学习java编程已经半年了,一路敲代码下来,现在也才1w+行代码量,也就菜鸟水准吧,但是在整个学习过程中,我一直在想,为什么很多培训老师,网上的文章都是要我们背一些代码?比如学习Arraylist的时候,教师就让我们先参考源代码写一遍,然
jvm指令集程序员是怎么炼成的 jvm 指令集
转自：http://blog.csdn.net/hudashi/article/details/7062675#comments 将值推送至栈顶时 const ldc push load指令 const系列该系列命令主要负责把简单的数值类型送到栈顶。(从常量池或者局部变量push到栈顶时均使用) 0x02 &nbs
Oracle字符集的查看查询和Oracle字符集的设置修改 aijuans oracle
本文主要讨论以下几个部分：如何查看查询oracle字符集、修改设置字符集以及常见的oracle utf8字符集和oracle exp 字符集问题。一、什么是Oracle字符集 Oracle字符集是一个字节数据的解释的符号集合,有大小之分,有相互的包容关系。ORACLE 支持国家语言的体系结构允许你使用本地化语言来存储，处理，检索数据。它使数据库工具，错误消息，排序次序，日期，时间，货
png在Ie6下透明度处理方法 antonyup_2006 css 浏览器 Firebug IE
由于之前到深圳现场支撑上线，当时为了解决个控件下载，我机器上的IE8老报个错，不得以把ie8卸载掉，换个Ie6,问题解决了，今天出差回来，用ie6登入另一个正在开发的系统，遇到了Png图片的问题，当然升级到ie8(ie8自带的开发人员工具调试前端页面JS之类的还是比较方便的，和FireBug一样，呵呵)，这个问题就解决了，但稍微做了下这个问题的处理。我们知道PNG是图像文件存储格式，查询资
表查询常用命令高级查询方法(二) 百合不是茶 oracle 分页查询分组查询联合查询
----------------------------------------------------分组查询 group by having --平均工资和最高工资 select avg(sal)平均工资,max(sal) from emp ; --每个部门的平均工资和最高工资
uploadify3.1版本参数使用详解 bijian1013 JavaScript uploadify3.1
使用：绑定的界面元素<input id='gallery'type='file'/>$("#gallery").uploadify({设置参数，参数如下}); 设置的属性： id: jQuery(this).attr('id'),//绑定的input的ID langFile: 'http://ww
精通Oracle10编程SQL(17)使用ORACLE系统包 bijian1013 oracle 数据库 plsql
/* *使用ORACLE系统包 */ --1.DBMS_OUTPUT --ENABLE:用于激活过程PUT,PUT_LINE,NEW_LINE,GET_LINE和GET_LINES的调用 --语法：DBMS_OUTPUT.enable(buffer_size in integer default 20000); --DISABLE:用于禁止对过程PUT,PUT_LINE,NEW
【JVM一】JVM垃圾回收日志 bit1129 垃圾回收
将JVM垃圾回收的日志记录下来，对于分析垃圾回收的运行状态，进而调整内存分配(年轻代，老年代，永久代的内存分配)等是很有意义的。JVM与垃圾回收日志相关的参数包括： -XX:+PrintGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -Xloggc -XX:+PrintGC 通
Toast使用白糖_ toast
Android中的Toast是一种简易的消息提示框，toast提示框不能被用户点击，toast会根据用户设置的显示时间后自动消失。创建Toast 两个方法创建Toast makeText(Context context, int resId, int duration) 参数：context是toast显示在
angular.identity boyitech AngularJS AngularJS API
angular.identiy 描述: 返回它第一参数的函数. 此函数多用于函数是编程. 使用方法: angular.identity(value); 参数详解: Param Type Details value * to be returned. 返回值: 传入的value 实例代码: <!DOCTYPE HTML>
java-两整数相除，求循环节 bylijinnan java
import java.util.ArrayList; import java.util.List; public class CircleDigitsInDivision { /** * 题目：求循环节，若整除则返回NULL，否则返回char*指向循环节。先写思路。函数原型：char*get_circle_digits(unsigned k,unsigned j)
Java 日期周年 Chen.H java C++c C#
/** * java日期操作(月末、周末等的日期操作) * * @author * */ public class DateUtil { /** */ /** * 取得某天相加(减)後的那一天 * * @param date * @param num *
[高考与专业]欢迎广大高中毕业生加入自动控制与计算机应用专业 comsci 计算机
不知道现在的高校还设置这个宽口径专业没有,自动控制与计算机应用专业,我就是这个专业毕业的,这个专业的课程非常多,既要学习自动控制方面的课程,也要学习计算机专业的课程,对数学也要求比较高.....如果有这个专业,欢迎大家报考...毕业出来之后,就业的途径非常广..... 以后
分层查询（Hierarchical Queries） daizj oracle 递归查询层次查询
Hierarchical Queries If a table contains hierarchical data, then you can select rows in a hierarchical order using the hierarchical query clause: hierarchical_query_clause::= start with condi
数据迁移 daysinsun 数据迁移
最近公司在重构一个医疗系统，原来的系统是两个.Net系统，现需要重构到java中。数据库分别为SQL Server和Mysql，现需要将数据库统一为Hana数据库，发现了几个问题，但最后通过努力都解决了。 1、原本通过Hana的数据迁移工具把数据是可以迁移过去的，在MySQl里面的字段为TEXT类型的到Hana里面就存储不了了，最后不得不更改为clob。 2、在数据插入的时候有些字段特别长
C语言学习二进制的表示示例 dcj3sjt126com c basic
进制的表示示例 # include <stdio.h> int main(void) { int i = 0x32C; printf("i = %d\n", i); /* printf的用法 %d表示以十进制输出 %x或%X表示以十六进制的输出 %o表示以八进制输出 */ return 0; }
NsTimer 和 UITableViewCell 之间的控制 dcj3sjt126com ios
情况是这样的: 一个UITableView, 每个Cell的内容是我自定义的 viewA viewA上面有很多的动画, 我需要添加NSTimer来做动画, 由于TableView的复用机制, 我添加的动画会不断开启, 没有停止, 动画会执行越来越多. 解决办法: 在配置cell的时候开始动画, 然后在cell结束显示的时候停止动画查找cell结束显示的代理
MySql中case when then 的使用 fanxiaolong casewhenthenend
select "主键", "项目编号", "项目名称","项目创建时间", "项目状态","部门名称","创建人" union (select pp.id as "主键", pp.project_number as &
Ehcache（01）——简介、基本操作 234390216 cache ehcache 简介 CacheManager crud
Ehcache简介目录 1 CacheManager 1.1 构造方法构建 1.2 静态方法构建 2 Cache 2.1&
最容易懂的javascript闭包学习入门 jackyrong JavaScript
http://www.ruanyifeng.com/blog/2009/08/learning_javascript_closures.html 闭包（closure）是Javascript语言的一个难点，也是它的特色，很多高级应用都要依靠闭包实现。下面就是我的学习笔记，对于Javascript初学者应该是很有用的。一、变量的作用域要理解闭包，首先必须理解Javascript特殊
提升网站转化率的四步优化方案 php教程分享数据结构 PHP 数据挖掘 Google 活动
网站开发完成后,我们在进行网站优化最关键的问题就是如何提高整体的转化率，这也是营销策略里最最重要的方面之一，并且也是网站综合运营实例的结果。文中分享了四大优化策略：调查、研究、优化、评估，这四大策略可以很好地帮助用户设计出高效的优化方案。 PHP开发的网站优化一个网站最关键和棘手的是，如何提高整体的转化率，这是任何营销策略里最重要的方面之一，而提升网站转化率是网站综合运营实力的结果。今天，我就分
web开发里什么是HTML5的WebSocket？ naruto1990 Web html5 浏览器 socket
当前火起来的HTML5语言里面，很多学者们都还没有完全了解这语言的效果情况，我最喜欢的Web开发技术就是正迅速变得流行的 WebSocket API。WebSocket 提供了一个受欢迎的技术，以替代我们过去几年一直在用的Ajax技术。这个新的API提供了一个方法，从客户端使用简单的语法有效地推动消息到服务器。让我们看一看6个HTML5教程介绍里的 WebSocket API：它可用于客户端、服
Socket初步编程——简单实现群聊 Everyday都不同 socket 网络编程初步认识
初次接触到socket网络编程，也参考了网络上众前辈的文章。尝试自己也写了一下，记录下过程吧：服务端：（接收客户端消息并把它们打印出来） public class SocketServer { private List<Socket> socketList = new ArrayList<Socket>(); public s
面试：Hashtable与HashMap的区别（结合线程） toknowme
昨天去了某钱公司面试，面试过程中被问道 Hashtable与HashMap的区别？当时就是回答了一点，Hashtable是线程安全的，HashMap是线程不安全的，说白了，就是Hashtable是的同步的，HashMap不是同步的，需要额外的处理一下。今天就动手写了一个例子，直接看代码吧 package com.learn.lesson001; import java
MVC设计模式的总结 xp9802 设计模式 mvc 框架 IOC
随着Web应用的商业逻辑包含逐渐复杂的公式分析计算、决策支持等，使客户机越来越不堪重负，因此将系统的商业分离出来。单独形成一部分，这样三层结构产生了。其中‘层’是逻辑上的划分。三层体系结构是将整个系统划分为如图2.1所示的结构[3] （1）表现层（Presentation layer）：包含表示代码、用户交互GUI、数据验证。该层用于向客户端用户提供GUI交互，它允许用户