墨鸦_Cormorant
墨鸦_Cormorant

Spring 框架（Spring Framework）使用详解

概述

Spring 体系概述

  • Spring 是于2003年兴起的一个 full-stack 轻量级的 Java 开源框架，由 Rod Johnson 创建，使用 Spring 可以更快、更轻松、更安全地进行 Java 编程
  • Spring 是一个生态体系，或一个超级粘合平台，常见的 Spring 项目有：Spring Boot，Spring Framework，Spring Data，Spring Cloud，Spring Cloud Data Flow，Spring Security，Spring GraphQL，Spring Session 和 Spring Web Services 等
  • Spring 提供了展现层 Spring MVC、持久层 Spring JDBC、业务层事务管理等众多的企业级应用技术，Spring 还能整合开源世界众多的第三方框架和类库，逐渐成为使用最多的 Java EE企业应用开源框架
  • Spring 并不等同于 Spring 框架（Spring Framework），这是常见的误区

Spring 框架（Spring Framework）

概述

  • Spring 框架，即 Spring Framework 框架，是 Spring 生态的其中一个重要项目，也是其他 Spring 全家桶（SpringMVC、SpringBoot、SpringCloud、SpringData等）的基础和核心
  • Spring 框架分为多个模块，应用程序可以选择需要的模块。Spring 框架的核心是 Core Container（核心容器）模块，包括配置模型和依赖注入机制
  • Spring 框架为不同的应用程序架构提供基础支持，包括消息传递、事务数据和持久性以及 Web
  • Spring 框架还包括基于 Servlet 的 Spring MVC Web 框架，以及并行的 Spring WebFlux 反应式 Web 框架
  • Spring 框架是分层的JavaSE/EE一站式轻量级开源框架，以 IOC（控制反转）和 AOP （面向切面编程）为核心

Spring 框架的特点

  • 方便解耦，简化开发：将所有对象的创建和依赖关系维护交给Spring管理
  • 方便集成各种优秀框架：Spring内部提供了对各种优秀框架（Struts2、Hibernate、MyBatis）的直接支持
  • 降低了Java EE API 使用难度：对 JAVA EE开发中一些API（ JDBC、JavaMail、远程调用）都提供了封装
  • 方便程序测试：支持 JUnit4，可以通过注解方便地测试 Spring 程序
  • AOP变成支持：面向切面编程，可以方便地实现对程序进行权限拦截和运行监控等功能
  • 声明式事务：通过配置就可以完成对事务的管理，无需编程

Spring 框架的架构和模块说明

Spring 框架（Spring Framework）使用详解_第1张图片

Spring 框架的主要模块

  • Core Container（核心容器）

    是其他模块建立的基础，由 Beans 模块、Core 核心模块、Context 上下文模块和 SpEL 表达式语言模块组成

    • Core（spring-core）：封装了Spring框架的底层部分，包括资源访问、类型转换以及Spring 框架基本的核心工具类

      Spring 其它组件要都要使用到这个包里的类，是其它组件的基本核心，也可以在自己的应用系统中使用这些工具类

      • 外部依赖：Commons Logging， (Log4J)
      • jar包：org.springframework spring-core 4.3.7.RELEASE

    • Beans（spring-beans）：提供了框架的基础部分，包括访问配置文件、控制反转（IOC）和依赖注入（DI）

      • 外部依赖：spring-core
      • jar包：org.springframework spring-beans 4.3.7.RELEASE

    • SpEL（spring-expression）：提供了强大的表达式语言支持，用于在运行时查询和处理对象图。该语言支持设置和获取属性值；属性赋值，方法调用，访问数组的内容，收集和索引器，逻辑和算术运算，命名变量，并从Spring的IOC容器的名字对象检索，它也支持列表选择和投影以及常见的列表聚合

      • jar包：org.springframework spring-expression 4.3.7.RELEASE

    • Context（spring-context）：上下文模块，建立在 Core 和 Beans 模块的基础之上，集成Beans模块并添加资源绑定、数据验证、国际化、Java EE支持、容器生命周期、事件传播等

      为Spring 核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类，JDNI 所需的全部类，instrumentation组件以及校验Validation 方面的相关类。

      • 外部依赖：spring-core，spring-beans，spring-expression，spring-aop
      • jar包：org.springframework spring-context 4.3.7.RELEASE

    依赖关系：

    Spring 框架（Spring Framework）使用详解_第2张图片

  • Data Access/Integration（数据访问与集成）

    包含模块：JDBC、ORM、OXM、JMS、Transaction

    • JDBC（spring-jdbc）：包含对Spring 对JDBC 数据访问进行封装的所有类

      • jar包：org.springframework spring-jdbc 4.3.7.RELEASE

    • ORM（spring-orm）：提供了与“对象-关系”映射框架集成的API，包括 JPA、JDO、Hibernate、MyBatis等。

    • OXM（spring-oxm）：提供了 Object/XML 映射的抽象层实现，如 JAXB、Castor、XMLBean、JiBX、XStream

      将 java对象映射成为XML数据，或者将 XML 数据映射成java对象

    • JMS（spring-jms）：java消息服务，提供了一套“消息生产者、消息消费者”模板，JMS用于两个应用程序之间，或者分布式系统中发送消息，进行异步通信

    • Transaction（spring-tx）：事务控制，为JDBC、Hibernate、JDO、JPA、Beans等提供的一致的声明式和编程式事务管理支持

      • jar包：org.springframework spring-tx 4.3.7.RELEASE

    依赖关系：

    Spring 框架（Spring Framework）使用详解_第3张图片

  • Web

    包括模块：Web、servlet、websocket、portlet

    • Web（spring-web）：提供了基本web集成特性，例如：多文件上传、使用 Servlet 监听器的 IOC 容器初始化以及 web 应用上下文

      包含Web 应用开发时，用到Spring 框架时所需的核心类，包括自动载入Web ApplicationContext 特性的类、Struts 与JSF 集成类、文件上传的支持类、Filter 类和大量工具辅助类

      • jar包：org.springframework spring-web 4.3.7.RELEASE

    • servlet（spring-webmvc）：提供了 SpringMVC Web 框架实现。SpringMVC 提供了基于注解的请求资源注入、更简单的数据绑定、数据验证等以及一套非常简易的 JSP 标签

      包含Spring MVC 框架相关的所有类，包括框架的Servlets，Web MVC框架，控制器和视图支持

      如果应用使用了独立的MVC 框架，则无需这个JAR 文件里的任何类

      • jar包：org.springframework spring-webmvc 4.3.7.RELEASE

    • WebSocket：提供了简单的接口，用户只需要实现接口就可以快速搭建 websocket server，从而实现双向通讯

    • Portlet（spring-webmvc-portlet）：提供了Portlet环境中MVC实现

    依赖关系：

    Spring 框架（Spring Framework）使用详解_第4张图片

  • AOP、aspects、spring-instrument 、messaging

    aop部分包含4个模块

    • AOP（spring-aop）：提供了面向切面编程，提供了比如日志记录、权限控制、性能统计等通用功能和业务逻辑分离的技术，并且能动态把这些功能添加到需要的代码中

      • jar包：org.springframework spring-aop 4.3.7.RELEASE

    • Aspects（spring-aspects）：提供与AspectJ的集成，是一个功能强大且成熟的面向切面编程框架

      以便可以方便的将面向方面的功能集成进IDE中，比如Eclipse AJDT

      • jar包：org.springframework spring-aspects 4.3.7.RELEASE

    • InStrumentation（spring-instrument）：检测，提供了类工具的支持和类加载器的实现

    • Messaging（消息处理）：提供了对消息传递体系结构和协议的支持

    依赖关系：

    Spring 框架（Spring Framework）使用详解_第5张图片

  • Test：Spring 支持 Junit 和 TestNG 测试框架，而且还额外提供了一些基于 Spring 的测试功能。


Spring 框架 的 API 体系

Spring Framework 的API体系异常庞大，暂时只介绍 BeanFactory 和 ApplicationContext：

  • BeanFactory

    • BeanFactory 是 Spring 的"心脏"，IOC 容器的核心接口，定义了IOC的基本功能
    • Spring 使用它来配置文档，管理bean的加载，实例化并维护bean之间的依赖关系，负责bean的声明周期

  • ApplicationContext

    • ApplicationContext 由 BeanFactory 派生而来，可以比喻为Spring的躯体
    • ApplicationContext 在 BeanFactory 的基础上添加了很多功能：
      • 支持了 aop 功能和 web 应用
      • MessageSource，提供国际化的消息访问
      • 通过配置来实现 BeanFactory 中很多编码才能实现的功能
    • ApplicationContext 的常用实现类：
      • ClassPathXmlApplicationContext：从classpath目录读取配置文件
      • FileSystemXmlApplicationContext：从文件系统或者url中读取配置文件
      • AnnotationConfigApplicationContext：读取注解。当使用注解配置容器对象时，需要使用此类来创建 spring
        容器

BeanFactory 和 ApplicationContext 的区别:

  • beanFactory 主要是面向 Spring 框架的基础设施，也就是供 spring 自身内部调用

    Applicationcontext 主要面向 Spring 的使用者

  • BeanFactroy 是在第一次使用到某个Bean（调用getBean()方法）时，才对该Bean进行加载实例化

    ApplicationContext 是在容器启动时，一次性创建并加载了所有的Bean

Spring 框架（Spring Framework）使用详解_第6张图片


Spring Boot 框架概述

  • Spring Boot 也是 Spring 生态中一个极其重要的项目，Spring Boot 是对 Spring Framework 的扩展，也可以说它是一个服务于框架的框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程

  • Spring Boot 的服务范围是简化配置文件，它消除了设置 Spring 应用程序所需的XML配置，即尽可能的自动配置 Spring 应用

  • Spring Boot 直接嵌入了 Tomcat、Jetty 或 Undertow（无需部署WAR文件），并且提供生产就绪功能，例如指标、运行状况检查和外部化配置等等，为更快和更高效的开发应用程序铺平了道路


IOC（控制反转）

IOC概述、IOC 容器工作原理

IOC（控制反转）是一种设计思想，目的是指导设计出更加松耦合的程序：

  • 控制：指的是对象控制权，在 java 中可以简单理解为对象的控制权限（比如对象的创建、销毁等权限）
  • 反转：指的是将对象的控制权由原来的程序员在类中主动控制反转到由 Spring 容器来控制
  • 主要功能：解耦

Spring IOC 容器 是对 IOC 思想的一种实现：

  • 对象的创建交由 Spring 框架管理，需要对象时从 Spring IOC 容器中获取即可
  • 底层原理：反射

Spring 的 IOC容器 工作原理：

  1. 当 Spring 的 IOC 容器加载时，会读取配置文件中的诸多 bean 配置

  2. 根据 bean 的 class 的值寻找对应的 Class 字节码文件

  3. 通过反射技术，创建出一个个对象

  4. 创建的对象会被存放到内部的一个 Map 结构中，等待被使用

  5. 当需要使用具体的对象时就无须手动创建，而是直接从 Spring 的IOC容器中


Spring IOC 的入门案例（xml）

案例：通过Spring中内置的容器获取对象

操作步骤：

  • 创建工程导入依赖
  • 配置接口和实现类
  • 编写Spring的配置文件
  • 测试：从容器中获取对象

创建工程导入依赖

    <dependencies>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.1.6.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
        dependency>
    dependencies>

创建Dao接口和实现类（略）

创建Spring配置文件

  • spring配置文件约定俗称：applicationContext.xml
  • spring配置文件放置到：resource目录下
  • spring配置文件，需要引入名称空间（约束）
  • 在spring的配置文件中通过 标签，定义对象id和实现类全类名

在resource目录下创建applicationContext.xml配置文件


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    
    
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql:///spring"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    bean>
    
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
    	<constructor-arg name="ds" ref="dataSource"/>
    bean>
    
    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
    	<property name="queryRunner" ref="queryRunner"/>
    bean>
    
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
    	<property name="accountDao" ref="accountDao"/>
    bean>
beans>

测试

import cn.test.dao.UserDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 测试从容器中获取对象
 */
public class UserDaoTest {

    public static void main(String[] args) {
        //1、根据配置文件获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2、调用容器的方法，获取对象
        UserDao userDao = (UserDao)ac.getBean("userDao");
        //3、测试
        userDao.save();
    }
}

执行过程分析

Spring 框架（Spring Framework）使用详解_第7张图片

初始化 Spring Bean 对象（xml）

方式1：默认无参构造函数

IOC容器通过反射调用，根据默认无参构造函数来创建类对象。如果 bean 中没有默认无参构造函数，将会创建失败。

<bean id="userDao" class="cn.test.dao.impl.UserDaoImpl">bean>

方式2：工厂模式创建对象

在Spring中还可以通过工厂模式来创建对象。工厂模式又分两种：

  • 静态工厂：不产生工厂的实例，直接调用工厂的静态方法创建对象
  • 实例工厂：先产生工厂的实例，再调用工厂实例的方法创建对象

（1）java代码编写工厂类

public class FactroyCreateBean {
    // 静态工厂
    public static UserDao createUserDao(){
    	return new UserDaoImpl();
    }
    // 实例工厂
    public UserDao createUserDaoSimple(){
    	return new UserDaoImpl();
    }
}

（2）xml配置文件配置


<bean id="userDao1" class="cn.test.factory.FactroyCreateBean" factory-method="createUserDao"/>

<bean id="factroyCreateBean" class="cn.test.factory.FactroyCreateBean"/>
<bean id="userDao2" factory-bean="factroyCreateBean" factory-method="createUserDaoSimple"/>

Spring Bean 的生命周期

概述、生命周期流程图

Bean对象生命周期指的是Bean创建到销毁的这么一段时间。

粗粒度生命周期：

  • spring中单例对象的生命周期为：

    出生：IOC容器加载时出生

    存活：IOC容器运行时存活

    死亡：IOC容器销毁时死亡

  • spring中多例对象的生命周期为：

    出生：使用对象时出生

    存活：一直存活

    死亡：由java垃圾回收器负


细粒度生命周期：

出生过程

  1. 实例化bean对象【IOC】

  2. 为对象属性赋值【DI】

  3. 处理实现的Aware接口

    ① 如果这个Bean已经实现了 BeanNameAware 接口，会调用它实现的 setBeanName(String beanId) 方法，此处传递的就是Spring配置文件中Bean的id值。

    ② 如果这个Bean已经实现了 BeanFactoryAware 接口，会调用它实现的 setBeanFactory() 方法，传递的是Spring工厂自身。

    ③ 如果这个Bean已经实现了 ApplicationContextAware 接口，会调用 setApplicationContext(ApplicationContext) 方法，传入Spring上下文。

  4. 通过 BeanPostProcessor 接口的 postProcessBeforeInitialization 方法对bean对象进行预处理

  5. 通过 InitializingBean 接口的 afterPropertiesSet 方法对bean对象进行处理

  6. 通过指定 init-method 方法对bean对象进行处理

  7. 通过 BeanPostProcessor 接口的 postProcessAfterInitialization 方法对bean对象进行后处理，这一步bean对象已经彻底创建成功了，可以做一些类似缓存的工作

死亡过程

  1. 如果Bean实现了 DisposableBean 接口，会调用其实现的 destroy() 方法。
  2. 如果指定 destroy-method 方法，可以在bean对象销毁前自动执行。

生命周期流程图

Spring 框架（Spring Framework）使用详解_第8张图片

测试案例：

public class UserDaoImpl implements UserDao, BeanNameAware, BeanFactoryAware,ApplicationContextAware, InitializingBean, DisposableBean {
    public UserDaoImpl() {
    	System.out.println("IOC");
    }
    
    private Integer id;
        public void setId(Integer id) {
        System.out.println("DI");
        this.id = id;
    }
    
    @Override
    public void setBeanName(String s) {
        System.out.println("BeanNameAware:"+s);
    }
    
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    	System.out.println("BeanFactoryAware");
    }
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    	System.out.println("ApplicationContextAware");
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
    	System.out.println("InitializingBean的afterPropertiesSet");
    }

    public void initMethod(){
    	System.out.println("init-method");
    }
    
    @Override
    public void save() {
    	System.out.println("保存成功！");
    }
    
    @Override
    public void destroy() throws Exception {
    	System.out.println("DisposableBean的destroy");
    }
    
    public void destroyMethod(){
    	System.out.println("destroy-method");
    }
}

public class MyBeanProcessor implements BeanPostProcessor {
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    	System.out.println("BeanPostProcessor的before");
    	return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor的after");
        return bean;
    }
}


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

    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl" init-method="initMethod" destroy method="destroyMethod">
        <property name="id" value="1"/>
    bean>
    <bean class="com.itheima.processor.MyBeanProcessor"/>
beans>

// 测试类
public class UserDaoImplTest {
    @Test
    public void save() {
        ClassPathXmlApplicationContext ac = new
        ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = ac.getBean(UserDao.class);
        userDao.save();
        ac.close();
    }
}

Spring Bean 的作用域

参考：https://blog.csdn.net/weixin_38676276/article/details/90382350

  • singleton：单例。在Spring IOC容器中仅存在一个共享的Bean实例。默认值

    当spring创建applicationContext容器的时候，spring会初始化所有的该作用域实例，加上lazy-init则可以避免预处理

  • prototype：原型(多例)

    每次从容器中调用Bean时，都返回一个新的实例，即每次调用getBean()相当于执行new XxxBean()

    创建后spring将不再对其管理

    （下面是在web项目下才用到的作用域）

  • request：仅在当前HTTP request内有效

    每次HTTP请求都会创建一个新的Bean

    spring创建后会继续监听，当处理请求结束后销毁实例

  • session：仅在当前HTTP Session内有效

    同一个HTTP Session共享一个Bean，不同Session使用不同Bean

    spring创建后会继续监听，当HTTP Session最终被废弃时，在该HTTP Session作用域内的bean也会被废弃掉

  • global-session：全局的web域。类似于servlet中的application。一般用于Portlet应用环境


定义 Bean 的配置信息（xml）

  • id：唯一标志（获取的时候，调用容器的getBean(“id”)）

  • class：实现类的全限定类名

  • scope：对象作用域（singleton（默认） | prototype | request | session | global-session）

  • init-method：对象创建成功之后，指定的初始化方法

  • destroy-method：容器关闭对象销毁之前，执行的销毁方法

    只有在scope=singleton（单例）的时候，才有效

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl" scope="prototype" 
      init-method="init" destroy-method="destroy"/>

依赖注入（xml）

依赖注入：Dependency Injection（DI）。 它是 spring 框架核心 IOC 的具体实现。在编写程序时， 通过控制反转，把对象的创建交给了 spring，然后在代码中需要对象时，进行依赖对象的注入。

IOC 具有两个功能：依赖查找，依赖注入

本质：向对象中的私有属性赋值

  • 构造方法

  • set方法调用


构造方法注入

  • 向对象中添加有参构造方法
public class UserServiceImpl implements UserService {

    private String name;
    private Integer age;

    public UserServiceImpl(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public void save() {
        System.out.println(name + age);
    }
}
  • 在spring的配置文件中，通过bean标签配置对象创建（需要添加构造方法参数）
    
    <bean id="userService" class="cn.test.service.impl.UserServiceImpl">
        <constructor-arg name="age" value="12">constructor-arg>
        <constructor-arg name="name" value="王者荣耀">constructor-arg>
    bean>

set 方法注入

  • 提供属性的set方法

  • 在spring配置文件中，通过bean结合property配置set方法调用

    <bean id="book" class="com.itheima.spring.Book">
    
    <property name="name" value="程序员" />
    <property name="price" value="1" />
    <property name="publishDate" ref="date" />
bean>

注入复杂类型（集合）

给类中的集合成员传值，它用的也是 set方法注入的方式，只不过变量的数据类型都是集合。 这里介绍注入数组、List、Set、Map、Properties。

（1） 注入数组数据

配置set方法

public class UserServiceImpl implements UserService {

    /**
     * 注入数组（array数组，list集合，set集合）
     */
    private String [] names;
    private List<String> lists;
    private Set<String> sets;

    public void setNames(String[] names) {
        this.names = names;
    }

    public void setLists(List<String> lists) {
        this.lists = lists;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

    @Override
    public void save() {
    }
}

spring配置文件

<bean id="book" class="com.itheima.spring.Book">
	
	<property name="list">
		<list>
			<value>1value>
			<value>2value>
		list>
	property>

	
	<property name="set">
		<set>
			<value>3value>
			<value>4value>
		set>
	property>

	
	<property name="array">
		<array>
			<value>5value>
			<value>6value>
		array>
	property>

	
	<property name="map">
		<map>
			<entry key="7" value="7-1" />
			<entry key="8" value="8-1" />
		map>
	property>

	
	<property name="properties">
		<props>
			<prop key="9">9-1prop>
			<prop key="10">10-1prop>
		props>
	property>
bean>

Spring 框架中的注解配置

介绍、注解和 xml 配置对应关系

  • 注解和 xml 是Spring提供的两种配置形式，二者的功能是完全一样的，都是要降低程序间的耦合

  • 注解的好处是配置简单，xml的好处是修改配置不用改动源码，企业开发中两种方式灵活使用

  • Spring中注解配置

    1. 注解 + xml 配置（开启注解的功能支持）
    2. 纯注解（Spring Boot + cloud））

  • 注意：在spring中使用注解开发，需要开启注解的功能支持（ioc注解，aop注解，事务注解）


注解和xml配置对应关系：

xml配置 注解配置 说明
< bean id=“” class=“” > @Component @Controller @Service @Repository 将类的实例化对象放入Spring容器管理
< property name=“” ref=“”> @Autowired @Qualifier @Resource 从Spring容器中获取对象注入属性
< property name=“” value=“”> @Value bean的简单属性注入
< bean scope=“”> @Scope 控制bean的作用范围
< bean init-method=“init”
destroy method=“destory” />		 @PostConstruct @PreDestroy bean创建之后和销毁之前分别调用的方法

开启包扫描（开启 IOC 注解支持）

开启包扫描（即 开启对 IOC 注解的支持）：

  1. 扫描指定包下的所有 java 类中的 Spring 注解
  2. 如果扫描到类上有 IOC 注解，就会把当前类交给 IOC 容器管理，当容器启动时，自动创建对象存入容器
  3. 如果扫描到属性上有 DI 注解，则依据依赖注入的规则，给属性注入值

方式1：xml配置方式 开启包扫描


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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/context
			    http://www.springframework.org/schema/context/spring-context.xsd">

    
    <context:component-scan base-package="cn.test">context:component-scan>
beans>

方式2：配置类注解方式 开启包扫描

/**
 * 1、声明配置类：@Configuration
 * 2、开启包扫描：@ComponentScan
 */
@Configuration
@ComponentScan(basePackages = "cn.test")
public class SpringConfig {
}

IOC 注解（对象创建的注解）

IOC 注解（对象创建的注解）说明：

  • 标注在想要被 IOC 容器管理的类上，表明创建对象交给容器管理

  • 当 Spring 容器启动时，根据包扫描配置自动的扫描到 IOC 注解，反射创建注解标注的对象，存入容器，委托容器管理

  • 默认存入容器的 id（唯一标识）为当前类名首字母小写。可以通过 value 属性自定义存入容器中对象的 id

一共有四个：

  •  **@Controller**：一般标注在表现层（web层）的类上

  •  **@Service**： 一般标注在业务层（service层）的类上

  •  **@Repository**： 一般标注在持久层（dao层）的类上

  •  **@Component**：组件， 非三层模式范围的类上使用

相当于xml中的如下配置

<bean id="userDaoImpl" class="cn.test.dao.impl.UserDaoImpl">bean>

生命周期的相关注解

  • @Scope ： 在类上配置对象的作用域

    通过value属性指定作用范围（singleton|prototype），默认为 singleton（单例）

  • @PostConstruct ： 配置对象创建后的触发动作

    当对象创建完成之后，自动执行的方法。相当于 xml 配置文件中的 init-method

  • @PreDestroy ：配置对象销毁前的触发动作（仅在 Scope = singleton 时有效）

    容器关闭，对象销毁之前执行的方法。相当于 xml 配置文件中的destory-method

示例：

@Repository
@Scope(value="singleton")
public class UserDaoImpl implements UserDao {

    public UserDaoImpl() {
        System.out.println("创建UserDaoImpl");
    }

    @Override
    public void save() {
        System.out.println("调用dao保存数据");
    }


    //初始化方法：在对象创建完成之后执行
    @PostConstruct
    public void init() {
        System.out.println("执行init方法");
    }

    //销毁方法：在容器关闭对象销毁之前执行
    @PreDestroy
    public void destory() {
        System.out.println("执行destory方法");
    }
}

DI 注解（依赖注入的注解）

DI 注解都相当于直接给属性赋值，而无需借助于 set 方法或构造方法

@Autowired

使用方式1：标注在属性上

  • 直接给属性赋值（通过 @Autowired 依赖注入，不需要配置 set 方法）

  • 默认是通过 by Type（根据类型，即接口类型）的形式从 IOC 容器中查找对象并给属性注入值

  • 如果 IOC 容器中存在多个与属性同类型的对象（一个接口有多个实现类），

    • 则会按照属性名（by Name）作为唯一标志从容器中查找对象并给属性注入值

    • 也可以和 @Qualifier 注解共同使用，指定唯一标志从容器中查找对象并给属性注入值

      • value：指定 IOC 容器中对象唯一标志（id）

      注意：@Qualifier 只能结合 @Autowired 一起使用

使用方式2：标注在方法上

  • 表示自动执行当前方法，如果方法有参数，会自动从IOC容器中寻找同类型的对象给参数传值
  • 也可以在参数上添加 @Qualifier(“IOC容器中对象id”) 注解按照名称寻找对象给参数传值

@Autowired 使用注意事项

  1. 只能在被 Spring 容器托管（标注了 @Controller 等 IOC 注解）的类中使用 @Autowired 注解

  2. 自动注入与权限修饰符无关，即使是 private 修饰的字段也可以自动注入

  3. 默认情况下，使用 @Autowired 注解进行自动注入的属性一定要被装配（ Spring 容器托管）

    如果在容器中找不到该类型的bean 进行注入，就会报错

    如果允许不被装配，可以将 @Autowired 的 required 属性为 false

  4. @Autowired 是基于类型的注入，如果当前类型属性在容器中只有一个 Bean，那么属性名不限制，但一般建议遵循类名首字母小写的规则

  5. 如果当前属性类型在容器中有个多个Bean，那么必须要通过属性名或者同时标注 @Qualifier 注解指定 Bean name


示例：

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    @Qualifier(value = "userDao2")		// 从容器中获取指定唯一标志的对象
    private UserDao userDao;

    @Override
    public void save() {
        userDao.save();
    }
}

@value

配置在属性上。可用于简单数据类型的注入，相当于 < property name="" value="" > ，但通常不这么使用

一般用于解析 properties 配置文件或注册中心的配置文件中的内容

  • 根据key值获取对应的 value，语法规则： @Value(“${key}”)
  • 使用步骤：
    1. properties 配置文件交给Spring容器管理
    2. 通过 @Value，从容器中得到配置项，并注入

示例：

（1） 配置jdbc.properties文件

jdbc.username=root
jdbc.password=root
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///heima23

（2） 配置文件交给Spring

修改spring配置文件applicationContext.xml

    
    <context:property-placeholder location="jdbc.properties">context:property-placeholder>

（3） 属性注入

@Repository(value = "userDao")
public class UserDaoImpl implements UserDao {

    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;

    public void save() {
        System.out.println(username);
        System.out.println(password);
        System.out.println(driver);
        System.out.println(url);
        System.out.println("调用dao11111完成保存");
    }
}

@Reource（了解）

jdk提供的依赖注入的注解，此注解在jdk9及以上版本已经移除

  • 只能放在属性上
  • 表示先按照属性名匹配 IOC 容器中对象id给属性注入值【by name】
  • 若没有成功，会继续根据当前属性的类型匹配IOC容器中同类型对象来注入值 【by type】
  • 若指定了 name 属性 @Resource(name = “对象id”)，则只能按照对象 id 注入值

示例：

@Service
public class UserServiceImpl implements UserService {
    @Resource(name = "userDao1")
    private UserDao userDao;

    @Override
    public void save() {
        userDao.save();
    }
}

Configuration 配置类（注解）

配置类中的常用注解：

  • @Configuration：标注在类上，声明该类为 Spring 配置类

    Spring 在启动的时候会自动扫描并加载所有配置类，配置 Spring 容器（应用上下文），将配置类中的 Bean 放入容器管理

  • @Bean：标注在 Spring 配置类中的方法上，注册 bean 对象到 IOC 容器

    • name 属性：给生成的bean指定唯一标志

    在 Spring 容器启动的时候，自动的扫描并执行所有配置了 @Bean 的方法，并将返回值存入Spring容器

    注意：

    • 被标注的方法，需要返回某个实例
    • 被标注的方法，可以配置依赖的属性参数，Spring 会自动从容器中获取到依赖的对象，自动调用方法

  • @ComponentScan：开启包扫描（Spring IOC注解支持），默认扫描当前包及子包下所有类

    • basePackage 属性：指定扫描的包路径。可以减少加载时间

    如果扫描到类上有 IOC 注解，就会把当前类交给 IOC 容器管理，当容器启动时，自动创建对象存入容器

    如果扫描到属性上有 DI 注解，则依据依赖注入的规则，给属性注入值

  • @PropertySource：加载本地 properties 文件交给 Spring 容器管理

    • value 属性：指定本地 properties 路径

  • @Import：在一个配置类中导入其它配置类的内容

    • value 属性：指定其他的配置类的 class 类路径

    Spring 支持多配置类（配置类的模块），若配置类臃肿，可以拆分配置类，然后在主配置类中引入子配置类（子配置类上不用配置注解）

示例：

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;

@Configuration		// 声明配置类
@ComponentScan(basePackages = "cn.test")	// 开启包扫描，并指定包扫描路径
@PropertySource(value="jdbc.properties")	// 通过注解将此文件交给spring容器管理
@Import(value=DataSourceConfig.class)		// 引入其他的配置类
public class SpringConfig {

    @Bean
    public QueryRunner getQueryRunner(DataSource dataSource) {
        QueryRunner qr = new QueryRunner(dataSource);
        return qr;
    }
}

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;

// 子配置类
public class DataSourceConfig {

    @Value("${jdbc.username}")
    private String username;

    @Value("${jdbc.password}")
    private String password;

    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.driver}")
    private String driver;

    @Bean
    public DataSource getDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driver);
        return dataSource;
    }
}

# properties文件
jdbc.username=root
jdbc.password=root
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///heima23

AOP（面向切面编程）

概念

AOP（（Aspect Oriented Programming）面向切面编程

  • 是一种思想，目的是在不修改源代码的基础上，对原有功能进行增强
  • 通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术
  • AOP是一种编程范式，是OOP的延续，在OOP基础之上进行横向开发。
  • AOP研究的不是每层内部如何开发，而是同一层面上各个模块之间的共性功能。比如：事务、日志、统计

Spring AOP 是对 AOP 思想的一种实现，将那些与业务无关，却为业务模块所共用的逻辑封装起来，减少系统的重复代码，降低模块间的耦合度。另外，AOP还能解决一些系统层面上的问题，比如日志、事务、权限等。

Spring 底层是通过动态代理的方式实现的 AOP。同时支持 jdk 和 cglib 动态代理，Spring会根据被代理的类是否有接口自动选择代理方式：

  • 如果有接口，就采用 JDK 动态代理（也可以强制使用 CGLIB 动态代理）

  • 没有接口就采用用 CGLIB 动态代理的方式


Spring AOP工作流程：

开发阶段分别开发，运行阶段组装运行

  • 开发阶段（开发者完成）

    • 开发共性功能，制作成增强

    • 开发非共性功能，制作成切点

    • 在配置文件中，声明切点与增强之间的关系，即切面

  • 运行阶段/容器启动阶段（AOP完成）

    1. Spring读取配置文件中的切面信息，根据切面中的描述，将 增强功能 增加在 目标对象 的 切点方法 上，动态创建代理对象
    2. 最后将经过代理之后对象放入容器中（注意：存入容器的是动态代理对象！）

术语及说明

  • 目标对象（target ）：需要被增强的对象，即切入点方法所在对象

  • 连接点（jointPoint）：被代理对象中的方法

  • 切点（pointCut）：按照AOP的规则去切(匹配)连接点，匹配出来的就叫切点，即 需要被增强的方法

    • 切入点表达式 ： execution(方法的修饰符 返回值类型 包名.类名.方法名(参数))

      切点表达式的作用：定义一组规则，用于在连接点（所有方法）中挑选切入点（被增强方法）

      支持通配符：

      *		// 一个或多个任意字符
..		// 配置到参数上，标识任意参数
    1. 方法修饰符可以省略
    2. 方法返回值可以通过 * 标识任意返回值类型
    3. 包名可以通过 * 标识任意包
    4. 类名可以通过 * 标识任意类
    5. 方法名可以通过 * 标识任意方法
    6. 参数可以通过 … 标识任意参数
    // 切入点的全统配方式，表示整个项目中所有类中所有方法都要被增强
execution(* *..*.*(..))
// 最常用的切入点表达式：精确到具体包路径
execution(* com.test.controller.*.*(..))

  • 增强(通知)（advice）：一个具体的增强功能。增强方法在切点方法的什么位置上执行

    Spring AOP 通知（增强）分为5种类型：

    • 前置通知（before）：在切点运行之前执行

    • 后置通知（after-returning）：在切点正常运行结束之后执行

    • 异常通知（after-throwing）：在切点发生异常的时候执行

    • 最终通知（after）：在切点的最终执行

    • 环绕通知（around）：一种特殊的通知，在一个方法中定义多个增强逻辑（和手动定义动态代理类似）

      环绕通知的自定义方法：

      1. 参数 ProceedingJoinPoint：被代理对象的方法
      2. 返回值：被增强方法的返回值

  • 代理对象（proxy ）：目标对象被增强后成为代理对象

  • 切面（aspect）：是一个设计概念，包含了Advice 和 Pointcut。切面 = 切入点 + 增强

    Advice定义了Aspect的任务和什么时候执行，Pointcut定义在哪里切入

    即 Aspect定义了一个什么样的增强功能，切入到哪个核心方法的哪个位置

  • 织入（Weaving）：一个动作。将增强代码加入到核心代码的过程就叫织入


配置 Spring AOP（xml）

xml文件 配置切入点

  • id：当前切点的唯一标志
  • expression：切入点表达式

xml文件 配置切面

  • id：当前切面的唯一标志
  • ref：指定当前切面使用哪个通知

xml文件 配置通知类型

  • method ： 切面类中的增强方法名
  • pointcut-ref：切入点的id

xml文件 配置AOP示例

	
    <aop:config>
        
        <aop:pointcut id="pt" expression="execution(* cn.test.dao.impl.*.*(..))"/>

        
        <aop:aspect ref="logger">
        	
            
            <aop:before method="before" pointcut-ref="pt">aop:before>
            
            <aop:after-returning method="afterReturning" pointcut-ref="pt">aop:after-returning>
            
            <aop:after-throwing method="afterThrowing" pointcut-ref="pt">aop:after-throwing>
            
            <aop:after method="after" pointcut-ref="pt">aop:after>-->
            
            <aop:around method="around" pointcut-ref="pt">aop:around>
        aop:aspect>
    aop:config>

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 切面类：此类中具有所有的增强代码逻辑
 */
public class Logger {

    /**
     * 前置通知：执行被代理对象方法之前执行
     * 方法：无参数，无返回值
     */
    public void before() {
        System.out.println("执行前置通知");
    }

    /**
     * 后置后置：正常执行被代理对象方法获取返回值之后执行
     */
    public void afterReturning() {
        System.out.println("执行后置通知");
    }

    /**
     * 异常通知：执行代码抛出异常的时候执行
     */
    public void afterThrowing() {
        System.out.println("执行异常通知");
    }


    /**
     * 最终通知：finally代码块中执行的逻辑
     */
    public void after() {
        System.out.println("执行最终通知");
    }

    /**
     * 环绕通知：在一个方法中定义多个增强逻辑
     */
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        Object obj = null;

        try {
            System.out.println("执行前置通知");
            //执行被代理对象方法
            obj = pjp.proceed();
            System.out.println("执行后置通知");
        }catch (Exception e){
            System.out.println("执行异常通知");
        }finally {
            System.out.println("执行最终通知");
        }
        return obj;
    }

配置 Spring AOP（注解）

AOP注解版有两种：

  • 基于 XML 结合注解的配置方式
  • 基于纯注解的配置方式

开启 AOP 注解支持（xml 方式）

xml配置文件

  • 开启IOC注解的支持，包扫描
    • 自定义的对象，通过IOC注解进行对象创建和依赖注入
    • 第三方的对象，通过XML配置对象创建和依赖注入
  • 开启AOP注解的支持，自动代理

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

    
    <context:component-scan base-package="cn.test">context:component-scan>

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

    
beans>

开启 AOP 注解支持（配置类方式）

  • @EnableAspectJAutoProxy：标注在配置类上，开启 aop 注解支持
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * 配置类
 */
@Configuration
@ComponentScan(basePackages = "cn.test")
@EnableAspectJAutoProxy
public class SpringConfig {
}

切面类（注解）

  • @Aspect：标注在自定义类上，声明切面类

    注意：该切面类同时需要标注 IOC注解（@Component），交给 Spring 容器管理

  • 在切面类中的通知（增强）方法上通过注解配置通知类型：

    • @Before：前置通知
    • @AfterReturning: 后置通知
    • @AfterThrowing：异常通知
    • @After：最终通知
    • @Around：环绕通知

    通知注解的属性：

    • value / argNames 属性：切入点表达式 或 被 @Pointcut 标注的方法名()

      	@Around("pt()")
    public Object around(ProceedingJoinPoint pjp)

  • @Pointcut：标注在切面类中的空的方法上，抽取公共的切入点表达式

    • value / argNames 属性：切入点表达式
    • 通知注解配置 方法名() 即可引入公共的切入点表达式
        @Pointcut(value="execution(* cn.test.service.impl.*.*(..))")
    public void pt() {}

/**
 * 切面类：此类中具有所有的增强代码逻辑
 */
@Component
@Aspect
public class Logger {

    /**
     * 前置通知：执行被代理对象方法之前执行
     * 方法：无参数，无返回值
     */
    //@Before(value="execution( * cn.test.dao.impl.*.*(..) )")
    public void before() {
        System.out.println("执行前置通知");
    }

    /**
     * 后置通知：正常执行被代理对象方法获取返回值之后执行
     */
    //@AfterReturning(value="execution( * cn.test.dao.impl.*.*(..) )")
    public void afterReturning() {
        System.out.println("执行后置通知");
    }

    /**
     * 异常通知：执行代码抛出异常的时候执行
     */
   // @AfterThrowing("execution( * cn.test.dao.impl.*.*(..) )")
    public void afterThrowing() {
        System.out.println("执行异常通知");
    }


    /**
     * 最终通知：finally代码块中执行的逻辑
     */
    //@After("execution( * cn.test.dao.impl.*.*(..) )")
    public void after() {
        System.out.println("执行最终通知");
    }

    /**
     * 环绕通知：在一个方法中定义多个增强逻辑
     */
    //@Around("execution( * cn.test.dao.impl.*.*(..) )")
    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        Object obj = null;
        try {
            System.out.println("1执行前置通知");
            //执行被代理对象方法
            obj = pjp.proceed();
            System.out.println("2执行后置通知");
        }catch (Exception e){
            System.out.println("3执行异常通知");
        }finally {
            System.out.println("4执行最终通知");
        }
        return obj;
    }
    
    // @Pointcut：抽取公共的切入点表达式
    @Pointcut(value="execution(* cn.test.service.impl.*.*(..))")
    public void pt() {}
}

四大通知的执行顺序问题

参考：https://blog.csdn.net/qq_45193304/article/details/109430545

SpringAOP四大通知（前置、后置、异常、最终通知）的执行顺序非常复杂，跟Spring版本、配置先后顺序、配置方式（xml | 注解）都有关，故建议使用环绕通知！

xml方式正确顺序配置aop的执行顺序：

try {
	// 前置通知(before) : 在切点运行之前执行
   
    // 切点执行，被代理对象方法调用
       
	// 后置通知(after-returning): 在切点正常运行结束之后执行
}catch (Exception e){
    // 异常通知(after-throwing): 在切点发生异常的时候执行
}finally {
    // 最终通知(after): 在切点的最终执行
}

注解方式正确顺序配置aop的执行顺序：

try{
    try{
        //@Before  -- 首先执行前置通知
        method.invoke(..); -- 然后执行切入点方法
    }finally{
        //@After  -- 再而肯定会执行最终通知 --- 注解配置的注意点
    }
    //@AfterReturning  -- 如果没有异常，则继续执行后置通知
    return;  -- 返回结果
}catch(){
    //@AfterThrowing  -- 如果有异常，则执行异常通知
}

Spring 中的事务管理

Spring支持两种事务管理方式：编程式事务和声明式事务。官方大力推荐使用声明式事务。

  • 编程式事务：将业务代码和事务代码放在一起书写，它的耦合性太高，开发中不使用

  • 声明式事务：

    • 声明式事务是建立在 AOP 的基础上的。

      其本质是在方法前后进行拦截，在方法开始之前创建事务，在方法结束后根据执行情况提交或回滚事务。

    • 声明式事务的优点：可以将事务代码和业务代码完全分离开发，然后通过配置的方式实现运行时组装运行。

    • 声明式事务的不足：只能作用到方法级别，无法像编程式事务那样可以作用到代码块级别


Spring 中事务管理相关 API

Spring中的事务控制主要就是通过这三个API实现的：

  • PlatformTransactionManager 接口：事务管理器，负责事务的管理，其子类负责具体工作
  • TransactionDefinition 接口：定义了事务的一些相关参数
  • TransactionStatus 接口：代表事务运行的一个实时状态

三者的关系：事务管理器 通过读取 事务定义参数 进行事务管理，然后会产生一系列的 事务状态


PlatformTransactionManager 接口：

  • Spring进行事务管理的一个根接口，使用其实现类做事务管理器（增强的事务处理的功能）

  • 接口方法：

    // 获取事务的状态信息
TransactionStatus getTransaction(TransactionDefinition def)
// 提交事务
void commit(TransactionStatus status)
// 回滚事务
void rollback(TransactionStatus status)

  • 常用实现类：

    • DataSourceTransactionManager ：使用 JDBC 和 MyBatis 进行持久化数据时使用
    • JpaTransactionManager ：使用 JPA 进行持久化时使用（jpa，hibernate）
    • HibernateTransactionManager ：使用Hibernate进行持久化数据时使用
    • JtaTransactionManager ：事务跨越多个事务管理源【分布式事务】时使用

TransactionStatus 接口 ：

  • 事务运行的一个实时状态

  • 接口方法

    // 是否是新事物
boolean isNewTransaction()
// 是否有回滚点
boolean hasSavepoint()
// 设置为只回滚事务
void setRollbackOnly()
// 是否是只回滚事务
boolean isRollbackOnly()
// 刷新事务状态 
void flush()
// 事务是否完成
boolean isCompleted()

TransactionDefinition 接口：

  • 事务的定义信息（事事务隔离级别，传播行为，是否只读事务，超时时间等）

Spring 框架（Spring Framework）使用详解_第9张图片

  • 事务隔离级别

    • Spring中配置事务，支持所有的4中隔离级别

    • 默认值：自动选择当前数据库合适的配置项

    • // 事务隔离级别相关【不设置事务隔离级别，可能引发脏读、不可重复读、幻读】
ISOLATION_READ_UNCOMMITTED	读未提交	mysq1支持四种，默认可重复度
ISOLATION_READ COMMITTED	读已提交	oracle支持两种(读己提交和串行化)，默认是读已提交
ISOLATION_REPEATABLE READ	可重复度
ISOLATION SERIALIZABLE		串行化

  • **事务传播行为：**描述多个方法嵌套调用时，被调用方法对事务的支持

    • PROPAGATION_REQUIRED = 0（必须有事务，这是默认值）

      如果存在一个事务，则加入到当前事务。如果没有事务则开启一个新的事务。

    • PROPAGATION_SUPPORTS = 1（支持有事务）

      如果存在一个事务，则加入到当前事务。如果没有事务则非事务运行。

    • PROPAGATION_MANDATORY = 2（强制有事务，自己还不负责创建）

      如果存在一个事务，则加入到当前事务。如果没有事务，则抛出异常。

    • PROPAGATION_REQUIRES_NEW = 3（必须有新的）

      总是开启一个新的事务。如果存在一个事务，则将这个存在的事务挂起，重新开启一个新的事务。

    • PROPAGATION_NOT_SUPPORTED = 4（不支持有事务）

      总是非事务地执行，并挂起任何存在的事务。

    • PROPAGATION_NEVER = 5（强制不要事务，自己还不负责挂起）

      总是非事务地执行，如果存在一个活动事务，则抛出异常

    • PROPAGATION_NESTED = 6（嵌套事务）

      如果一个活动的事务存在，则运行在一个嵌套的事务中。如果没有活动事务, 则开启一个新的事务。

      内层事务依赖于外层事务。外层事务失败时，会回滚内层事务所做的动作。

      而内层事务操作失败并不会引起外层事务的回滚

  • 是否只读事务

    isReadOnly ： true | false(默认)

    只读事务： 只能查询，不能增 删 改。只读事务只能用于查询方法

  • 事务超时时长

    TIMEOUT_DEFAULT = -1 ：事务的超时时间，需要底层数据库支持才能使用此配置，默认值是 -1，代表无限制。

    超时时间：使用默认值


声明式事务（xml 配置事务）

基于XML的方式完成声明式事务配置：

  • 配置事务管理器交给Spring容器管理（切面类）
  • 配置事务通知
  • 配置事务的AOP

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

    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource">property>
    bean>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="root">property>
        <property name="password" value="root">property>
        <property name="driverClassName" value="com.mysql.jdbc.Driver">property>
        <property name="url" value="jdbc:mysql:///heima23">property>
    bean>

    
    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource">property>
    bean>
    
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            
            <tx:method name="save*" propagation="REQUIRED" read-only="false">tx:method>
            <tx:method name="update*">tx:method>
            <tx:method name="delete*">tx:method>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true">tx:method>
            <tx:method name="*">tx:method>
        tx:attributes>
    tx:advice>
    
    <aop:config>
        
        <aop:pointcut id="pt" expression="execution(* cn.test.service.impl.*.*(..))"/>
        
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt">aop:advisor>
    aop:config>
beans>

声明式事务（注解）

开启事务注解支持（xml 方式）

  • 在XML配置文件中，开启事务注解的支持：事务注解驱动
  • 在XML配置文件中，创建事务管理器交给容器管理
  • 在需要事务的类或者方法上，使用 @Transactional 注解配置事务

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

    
    <tx:annotation-driven>tx:annotation-driven>

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

    

    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource">property>
    bean>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="root">property>
        <property name="password" value="root">property>
        <property name="driverClassName" value="com.mysql.jdbc.Driver">property>
        <property name="url" value="jdbc:mysql:///test">property>
    bean>
beans>

开启事务注解支持（配置类方式）

  • @EnableTransactionManagement：标注在配置类上，开启事务注解支持
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.sql.DataSource;

@Configuration
@ComponentScan(basePackages = "cn.test")
@EnableTransactionManagement
public class SpringConfig {

    /**
     * 创建datasource
     */
    @Bean
    public DataSource getDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        dataSource.setUrl("jdbc:mysql:///test");
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        return dataSource;
    }

    /**
     * 创建jdbctemplate
     *  1、从容器中获取datasource
     *  2、调用方法
     */
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    /**
     * 创建事务管理器
     */
    @Bean
    public PlatformTransactionManager getManager(DataSource dataSource) {
        DataSourceTransactionManager manager = new DataSourceTransactionManager();
        manager.setDataSource(dataSource);
        return manager;
    }
}

声明式事务注解的使用

  • @Transactional：配置事务

    常用属性：

    • rollbackFor 属性：设置需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，则进行事务回滚

      • 指定单一异常类：@Transactional(rollbackFor=Exception.class)

      • 指定多个异常类：@Transactional(rollbackFor={RuntimeException.class, Exception.class})

    • readOnly 属性：是否只读事务 （ true | false(默认值) ）

    • propagation 属性：事务传播行为 ( SUPPORTS | REQUIRED(默认值) ）

    • transactionManager 属性：多个事务管理器托管在 Spring 容器中时，指定事务管理器的 bean 名称

    • isolation 属性：设置底层数据库的事务隔离级别，事务隔离级别用于处理多事务并发的情况

      通常使用数据库的默认隔离级别即可，基本不需要进行设置

    • noRollbackFor 属性：设置不需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，不进行事务回滚

    标注位置说明：

    • 标注在类上：该类中所有方法都具有相同的事务配置
    • 标注在方法上：该方法具有事务配置
    • 同时标注在类上和方法上：就近原则（方法上的事务配置生效）
import cn.test.dao.AccountDao;
import cn.test.domain.Account;
import cn.test.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional(propagation = Propagation.SUPPORTS)
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    @Transactional
    //@Transactional(propagation = Propagation.REQUIRED,readOnly = false)
    public void transfer(String sourceName, String targetName, float money) throws Exception {
        //1、根据账户名称查询两个账户
        Account sourceAccount = accountDao.findByName(sourceName); //转出账户
        Account targetAccount = accountDao.findByName(targetName); //转入账户
        //2、操作金额转换（转出账户扣除金额，转入账户添加金额）
        sourceAccount.setMoney(sourceAccount.getMoney() - money);
        targetAccount.setMoney(targetAccount.getMoney() + money);
        //3、更新账户
        accountDao.update(sourceAccount);
        int i=1/0;
        accountDao.update(targetAccount);
    }
}

拓展

Spring 整合单元测试

当在单元测试中，点击 run 的时候，底层工作的其实是一个运行器，默认是 junit 提供的 ParentRunner 运行器，它是不认识Spring的环境，这也就意味着，它无法从 Spring 的容器中获取bean。

如果想要从 Spring 的容器中获取对象，需要使用 Spring 提供的运行器。

  • 引入依赖

    <dependency>
    <groupId>junitgroupId>
    <artifactId>junitartifactId>
    <version>4.12version>
dependency>

    
<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-testartifactId>
    <version>5.1.6.RELEASEversion>
dependency>

  • @RunWith 注解：设置单元测试的运行器，通过 value 属性指定单元测试运行环境

    • JUnit4.class ：指定使用 JUnit4 来运行
    • SpringJUnit4ClassRunner.class ：Spring 测试环境
    • SpringRunner.class：Spring 测试环境

    注：

    • SpringRunner extends SpringJUnit4ClassRunner.class

    • 使用上 JUnit4.12 或更高版本以上 SpringRunner，SpringJUnit4ClassRunner 都可以使用

      但是推荐使用 SpringRunner，final类型，安全

    • JUnit4.12 以下版本就只能使用 SpringJUnit4ClassRunner

  • @ContextConfiguration 注解：指定容器的配置信息

    • localtions 属性：配置文件路径
    • classes 属性：配置类
@RunWith(SpringRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class AccountJunitTest {

    @Autowired
    private AccountService accountService;

    //测试保存
    @Test
    public void testInsert() {
        //3、调用方法保存
        Account account = new Account();
        account.setMoney(100f);
        account.setName("小李1");
        accountService.saveAccount(account);
    }
}

配置文件的模块化

若配置都集中配在了一个applicationContext.xml文件中，当开发人员过多时， 如果所有bean都配置到同一个配置文件中，会使这个文件巨大，而且也不方便维护。针对这个问题，Spring提供了多配置文件的方式，也就是所谓的配置文件模块化。

  1. 并列的多个配置文件
    直接编写多个配置文件，比如说beans1.xml，beans2.xml…, 然后在创建ApplicationContext的时候，直接
    传入多个配置文件。
ApplicationContext act = new ClassPathXmlApplicationContext("beans1.xml","beans2.xml","...");
  1. 主从配置文件
    先陪一个主配置文件，然后在里面导入其它的配置文件。
  <import resource="beans1.xml" />
  <import resource="beans2.xml" />

  
  <context:property-placeholder location="classpath:db.properties"/>

注意事项：

  • 同一个xml文件中不能出现相同名称的bean，如果出现会报错
  • 多个xml文件如果出现相同名称的bean，不会报错，但是后加载的会覆盖前加载的bean，所以企业开发中尽
    量保证bean的名称是唯一的。

Spring Bean 单例的高并发安全问题

Spring的bean默认都是单例的，某些情况下，单例是并发不安全的，以Controller举例，问题根源在于，若在Controller中定义成员变量，多个请求来临，进入的都是同一个单例的Controller对象，若对此成员变量的值进行修改操作，则会互相影响，无法达到并发安全（不同于线程隔离的概念）的效果。

抛出问题

多次访问此url，可以看到每次的结果都是自增的，所以这样的代码显然是并发不安全的。

@Controller
public class HomeController {
    private int i;
    @GetMapping("testsingleton1")
    @ResponseBody
    public int test1() {
        return ++i;
    }
}

解决方案

方案1：尽量避免使用成员变量

在业务允许的条件下，尽量避免使用成员变量，使用方法中的局部变量


方案2：使用并发安全的类

Java作为功能性超强的编程语言，API丰富，如果非要在单例bean中使用成员变量，可以考虑使用并发安全的容器，如ConcurrentHashMap、ConcurrentHashSet等，将成员变量（一般可以是当前运行中的任务列表等这类变量）包装到这些并发安全的容器中进行管理即可。


方案3：分布式或微服务的并发安全

如果还要进一步考虑到微服务或分布式服务的影响，方案2便不足以处理了，所以可以借助于可以共享某些信息的分布式缓存中间件如Redis等，这样即可保证同一种服务的不同服务实例都拥有同一份共享信息（如当前运行中的任务列表等这类变量）。


方案4：单例变原型

对web项目，可以Controller类上加注解@Scope(“prototype”)或@Scope(“request”)，对非web项目，在Component类上添加注解@Scope(“prototype”)。

优点：实现简单

缺点：很大程度上增大了bean创建实例化销毁的服务器资源开销


不可用方案：线程隔离类ThreadLocal

web服务器默认的请求线程池大小为10，这10个核心线程可以被之后不同的Http请求复用。

ThreadLocal的方式可以达到线程隔离，但还是无法达到并发安全。


使用 @Autowired 注解给静态变量赋值

描述：

在一些工具类中可能会用到Ioc容器中的对象，而工具类中的成员变量往往是静态的，此时使用@Autowired注解就会出现NullpointerException（空指针异常）。

原理剖析：

静态变量、类变量不是对象的属性，而是一个类的属性，所以静态方法是属于类（class）的，普通方法才是属于实体对象（也就是New出来的对象）的，spring注入是在容器中实例化对象，所以不能使用静态方法。

而使用静态变量、类变量扩大了静态方法的使用范围。静态方法在spring是不推荐使用的，依赖注入的主要目的，是让容器去产生一个对象的实例，然后在整个生命周期中使用他们，同时也让testing工作更加容易。

一旦使用静态方法，就不再需要去产生这个类的实例，这会让testing变得更加困难，同时也不能为一个给定的类，依靠注入方式去产生多个具有不同的依赖环境的实例，这种static field是隐含共享的，并且是一种global全局状态，spring同样不推荐这样去做。


**解决方案1：**将@Autowire注解加到set方法上

@Component
public class Test {
    
    private static SessionFactory sessionFactory;
    
    @Autowired
    public void setSessionFactory(SessionFactory sessionFactory) {
        Test.sessionFactory = sessionFactory;
    }
}

**解决方案2：**用@PostConstruct注解

@Component
public class Test {
    
    private static SessionFactory sessionFactory;
    
    @Autowired
    private SessionFactory sessionFactory2;
    
    @PostConstruct
    public void beforeInit() {
        SessionFactory = sessionFactory2;
    }
}

**解决方案3：**将@Autowire注解加到构造方法上

@Component
public class Test {
    
    private static SessionFactory sessionFactory;
    
    @Autowired
    public Test(SessionFactory sessionFactory) {
        Test.SessionFactory = SessionFactory;
    }
}

非容器中的类调用容器中的类

描述：

使用@Autowired注入对象时，一般被注入的类都带有@Coponent、@Controller、@Service 、@repository等注解才可以。注入类和被注入类都被spring所管理，可以完成调用。但是当非容器类（没加以上注解时）使用@Autowired调用容器中的类时，注入对象为空，报空指针异常。

解决方案：

创建工具类BeanUtils，在这个工具类中的getBean可以得到容器中的类，在非容器类中使用

@Component
public class BeanUtils implements ApplicationContextAware {
    /**
     * 以静态变量保存ApplicationContext，可在任意代码中取出ApplicaitonContext.
     */
    private static ApplicationContext context;

    /**
     * 实现ApplicationContextAware接口的context注入函数, 将其存入静态变量.
     */
    @Override
    public void setApplicationContext(ApplicationContext context) {
        BeanUtils.context = context;
    }

    public static ApplicationContext getApplicationContext() {
        return context;
    }

    /**
     * 从静态变量ApplicationContext中取得Bean, 自动转型为所赋值对象的类型.  方法返回值的类型由调用者决定
     */
    public static <T> T getBean(String name) {
        return (T) context.getBean(name);
    }

    /// 获取当前环境
    public String getActiveProfile() {
        return context.getEnvironment().getActiveProfiles()[0];
    }
}

非容器类中使用容器中的类

public class StationFactory {
    Map<String, StationOperation> map = new HashMap<>();
    {
        map.put("定损中心主管指标表", BeanUtils.getBean("leadDSZXOperation"));
        map.put("定损中心员工指标表", BeanUtils.getBean("empDSZXOperation"));
        map.put("视频查勘中心主管指标表", BeanUtils.getBean("leadVideoSurveyCenterOperation"));
        map.put("视频查勘中心员工指标表", BeanUtils.getBean("empVideoSurveyCenterOperation"));
        map.put("视频定损中心主管指标表", BeanUtils.getBean("leadVideoDSCenterOperation"));
	}
}

你可能感兴趣的:(#,Spring全家桶,spring,java,ioc,aop)

  • 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开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 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前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • ARM驱动学习之4小结 JT灬新一 嵌入式C++arm开发学习linux
    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
  • 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 Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、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 pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • spring如何整合druid连接池？ 惜.己 springspringjunit数据库javaidea后端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基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、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 面试题汇总与解析springboot后端java中间件开发语言
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • Spring MVC 全面指南：从入门到精通的详细解析 一杯梅子酱 技术栈学习springmvcjava
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
  • Spring Boot中实现跨域请求 BABA8891 springboot后端java
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • java杨辉三角 3213213333332132 java基础
    package com.algorithm; /** * @Description 杨辉三角 * @author FuJianyong * 2015-1-22上午10:10:59 */ public class YangHui { public static void main(String[] args) { //初始化二维数组长度 int[][] y
  • 《大话重构》之大布局的辛酸历史 白糖_ 重构
    《大话重构》中提到“大布局你伤不起”，如果企图重构一个陈旧的大型系统是有非常大的风险，重构不是想象中那么简单。我目前所在公司正好对产品做了一次“大布局重构”，下面我就分享这个“大布局”项目经验给大家。   背景         公司专注于企业级管理产品软件，企业有大中小之分，在2000年初公司用JSP/Servlet开发了一套针对中
  • 电驴链接在线视频播放源码 dubinwei 源码电驴播放器视频ed2k
    本项目是个搜索电驴（ed2k）链接的应用,借助于磁力视频播放器（官网： http://loveandroid.duapp.com/ 开放平台），可以实现在线播放视频，也可以用迅雷或者其他下载工具下载。 项目源码： http://git.oschina.net/svo/Emule,动态更新。也可从附件中下载。 项目源码依赖于两个库项目，库项目一链接： http://git.oschina.
  • Javascript中函数的toString()方法 周凡杨 JavaScriptjstoStringfunctionobject
    简述     The toString() method returns a string representing the source code of the function.     简译之，Javascript的toString()方法返回一个代表函数源代码的字符串。 句法     function.
  • struts处理自定义异常 g21121 struts
    很多时候我们会用到自定义异常来表示特定的错误情况，自定义异常比较简单，只要分清是运行时异常还是非运行时异常即可，运行时异常不需要捕获，继承自RuntimeException，是由容器自己抛出，例如空指针异常。 非运行时异常继承自Exception，在抛出后需要捕获，例如文件未找到异常。 此处我们用的是非运行时异常，首先定义一个异常LoginException: /** * 类描述：登录相
  • Linux中find常见用法示例 510888780 linux
    Linux中find常见用法示例 ·find   path   -option   [   -print ]   [ -exec   -ok   command ]   {} \; find命令的参数；
  • SpringMVC的各种参数绑定方式 Harry642 springMVC绑定表单
    1. 基本数据类型(以int为例，其他类似)： Controller代码： @RequestMapping("saysth.do") public void test(int count) { } 表单代码： <form action="saysth.do" method="post&q
  • Java 获取Oracle ROWID aijuans javaoracle
    A ROWID is an identification tag unique for each row of an Oracle Database table. The ROWID can be thought of as a virtual column, containing the ID for each row. The oracle.sql.ROWID class i
  • java获取方法的参数名 antlove javajdkparametermethodreflect
    reflect.ClassInformationUtil.java package reflect; import javassist.ClassPool; import javassist.CtClass; import javassist.CtMethod; import javassist.Modifier; import javassist.bytecode.CodeAtt
  • JAVA正则表达式匹配 查找 替换 提取操作 百合不是茶 java正则表达式替换提取查找
    正则表达式的查找;主要是用到String类中的split();       String str;      str.split();方法中传入按照什么规则截取,返回一个String数组   常见的截取规则: str.split("\\.")按照.来截取 str.
  • Java中equals()与hashCode()方法详解 bijian1013 javasetequals()hashCode()
    一.equals()方法详解     equals()方法在object类中定义如下：  public boolean equals(Object obj) { return (this == obj); }    很明显是对两个对象的地址值进行的比较（即比较引用是否相同）。但是我们知道，String 、Math、I
  • 精通Oracle10编程SQL(4)使用SQL语句 bijian1013 oracle数据库plsql
    --工资级别表 create table SALGRADE ( GRADE NUMBER(10), LOSAL NUMBER(10,2), HISAL NUMBER(10,2) ) insert into SALGRADE values(1,0,100); insert into SALGRADE values(2,100,200); inser
  • 【Nginx二】Nginx作为静态文件HTTP服务器 bit1129 HTTP服务器
     Nginx作为静态文件HTTP服务器 在本地系统中创建/data/www目录，存放html文件(包括index.html) 创建/data/images目录，存放imags图片 在主配置文件中添加http指令   http { server { listen 80; server_name
  • kafka获得最新partition offset blackproof kafkapartitionoffset最新
    kafka获得partition下标，需要用到kafka的simpleconsumer   import java.util.ArrayList; import java.util.Collections; import java.util.Date; import java.util.HashMap; import java.util.List; import java.
  • centos 7安装docker两种方式 ronin47
          第一种是采用yum 方式              yum install -y docker           
  • java-60-在O(1)时间删除链表结点 bylijinnan java
    public class DeleteNode_O1_Time { /** * Q 60 在O(1)时间删除链表结点 * 给定链表的头指针和一个结点指针(!!)，在O(1)时间删除该结点 * * Assume the list is: * head->...->nodeToDelete->mNode->nNode->..
  • nginx利用proxy_cache来缓存文件 cfyme cache
    user  zhangy users; worker_processes 10; error_log  /var/vlogs/nginx_error.log  crit; pid        /var/vlogs/nginx.pid; #Specifies the value for ma
  • [JWFD开源工作流]JWFD嵌入式语法分析器负号的使用问题 comsci 嵌入式
        假如我们需要用JWFD的语法分析模块定义一个带负号的方程式，直接在方程式之前添加负号是不正确的，而必须这样做：     string str01 = "a=3.14;b=2.71;c=0;c-((a*a)+(b*b))"     定义一个0整数c,然后用这个整数c去
  • 如何集成支付宝官方文档 dai_lm android
    官方文档下载地址 https://b.alipay.com/order/productDetail.htm?productId=2012120700377310&tabId=4#ps-tabinfo-hash 集成的必要条件 1. 需要有自己的Server接收支付宝的消息 2. 需要先制作app，然后提交支付宝审核，通过后才能集成 调试的时候估计会真的扣款，请注意
  • 应该在什么时候使用Hadoop datamachine hadoop
    原帖地址：http://blog.chinaunix.net/uid-301743-id-3925358.html 存档，某些观点与我不谋而合，过度技术化不可取，且hadoop并非万能。 --------------------------------------------万能的分割线-------------------------------- 有人问我，“你在大数据和Hado
  • 在GridView中对于有外键的字段使用关联模型进行搜索和排序 dcj3sjt126com yii
    在GridView中使用关联模型进行搜索和排序 首先我们有两个模型它们直接有关联: class Author extends CActiveRecord { ... } class Post extends CActiveRecord { ... function relations() { return array( '
  • 使用NSString 的格式化大全 dcj3sjt126com Objective-C
    格式定义The format specifiers supported by the NSString formatting methods and CFString formatting functions follow the IEEE printf specification; the specifiers are summarized in Table 1. Note that you c
  • 使用activeX插件对象object滚动有重影 蕃薯耀 activeX插件滚动有重影
      使用activeX插件对象object滚动有重影   <object style="width:0;" id="abc" classid="CLSID:D3E3970F-2927-9680-BBB4-5D0889909DF6" codebase="activex/OAX339.CAB#
  • SpringMVC4零配置 hanqunfeng springmvc4
    基于Servlet3.0规范和SpringMVC4注解式配置方式，实现零xml配置，弄了个小demo，供交流讨论。     项目说明如下： 1.db.sql是项目中用到的表，数据库使用的是oracle11g 2.该项目使用mvn进行管理，私服为自搭建nexus,项目只用到一个第三方 jar，就是oracle的驱动； 3.默认项目为零配置启动，如果需要更改启动方式，请
  • 《开源框架那点事儿16》：缓存相关代码的演变 j2eetop 开源框架
    问题引入 上次我参与某个大型项目的优化工作，由于系统要求有比较高的TPS，因此就免不了要使用缓冲。 该项目中用的缓冲比较多，有MemCache，有Redis，有的还需要提供二级缓冲，也就是说应用服务器这层也可以设置一些缓冲。 当然去看相关实现代代码的时候，大致是下面的样子。 [java] view plain copy print ? public vo
  • AngularJS浅析 kvhur JavaScript
    概念 AngularJS is a structural framework for dynamic web apps. 了解更多详情请见原文链接：http://www.gbtags.com/gb/share/5726.htm Directive 扩展html，给html添加声明语句，以便实现自己的需求。对于页面中html元素以ng为前缀的属性名称，ng是angular的命名空间
  • 架构师之jdk的bug排查(一)---------------split的点号陷阱 nannan408 split
    1.前言.    jdk1.6的lang包的split方法是有bug的,它不能有效识别A.b.c这种类型,导致截取长度始终是0.而对于其他字符,则无此问题.不知道官方有没有修复这个bug. 2.代码 String[] paths = "object.object2.prop11".split("'"); System.ou
  • 如何对10亿数据量级的mongoDB作高效的全表扫描 quentinXXZ mongodb
      本文链接:  http://quentinXXZ.iteye.com/blog/2149440 一、正常情况下，不应该有这种需求 首先，大家应该有个概念，标题中的这个问题，在大多情况下是一个伪命题，不应该被提出来。要知道，对于一般较大数据量的数据库，全表查询，这种操作一般情况下是不应该出现的，在做正常查询的时候，如果是范围查询，你至少应该要加上limit。 说一下，
  • C语言算法之水仙花数 qiufeihu c算法
    /** * 水仙花数 */ #include <stdio.h> #define N 10 int main() { int x,y,z; for(x=1;x<=N;x++) for(y=0;y<=N;y++) for(z=0;z<=N;z++) if(x*100+y*10+z == x*x*x
  • JSP指令 wyzuomumu jsp
    jsp指令的一般语法格式： <%@ 指令名 属性 =”值 ” %> 常用的三种指令： page,include,taglib page指令语法形式： <%@ page 属性 1=”值 1” 属性 2=”值 2”%> include指令语法形式： <%@include file=”relative url”%> (jsp可以通过 include
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他