code@fzk

Spring核心技术与简单使用

Spring

文章目录

Spring
- 1、Spring 概述
- - Spring 是什么
  - Spring 的优势
- 2、IOC（控制反转）
- - 程序的耦合和解耦
  - - 耦合和解耦概念
    - 工厂模式解耦
  - IOC 的概念和作用
  - - IOC 控制反转
  - 基于 XML 的配置实现 IOC
  - - 步骤（四步）
    - IOC 中 bean 标签和管理对象
    - - bean 标签
      - bean 的作用范围和生命周期
      - 实例化 Bean 的三种方式
      - Spring 的依赖注入
      - 依赖注入的概念
        
        构造函数注入
        
        set 方法的注入:（更常用）
        
        复杂类型的注入/集合类型的注入
  - 使用 spring 的 IoC 的实现账户的CRUD (增删改查)
  - 基于注解的配置实现 IOC
  - - 步骤（四步）
    - 常用注解
    - - 用于创建对象
      - 用于改变作用范围
      - 和生命周期相关
      - 用于注入数据
  - Spring 注解和 XML 的选择问题
  - Spring 的纯注解配置
- 3、Spring 整合 Junit
- - 步骤（四步）
- 4、AOP（面向切面编程）
- - AOP 概述
  - - AOP 概念
    - AOP 的作用及优势
    - 动态代理技术实现（CRUD）
  - Spring 中的 AOP
  - - AOP 相关术语
    - 基于 XML 的 AOP 配置
    - - 步骤（七步）
      - 标签
      - aop:config
        
        aop:aspect
        
        aop:before、aop:after-returning、aop:after-throwing、aop:after
        
        aop:around（环绕通知）
        
        aop:pointcut
    - 基于注解的 AOP 配置
    - - 步骤（八步）
      - 注解
      - @Aspect
        
        @Before 、 @AfterReturning 、 @AfterThrowing 、@After
        
        @Around
        
        @Pointcut
        
        @EnableAspectJAutoProxy（纯注解的配置方式）
- 5、Spring 中的 JdbcTemplate
- - 概述
  - JdbcTemplate 的增删改查操作
  - - 不在 dao 中使用 JdbcTemplate
    - 在 dao 中使用 JdbcTemplate
    - - 方法一
      - 方法二：让 dao 继承 JdbcDaoSupport
- 6、Spring 中的事务控制
- - Spring 中事务控制的 API 介绍
  - - 事务的隔离级别
    - 事务的传播行为
    - 超时时间
    - 是否是只读事务
  - 基于 XML 的声明式事务控制
  - - 步骤（十步）
    - 标签
    - - tx:advice
      - tx:attributes、tx:method
      - aop:advisor
  - 基于注解的配置方式
  - - 步骤（七步）
    - 不使用 xml 的配置方式
    - 注解
    - - @Transactional

1、Spring 概述

Spring 是什么

Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以 IOC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 SpringMVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的 Java EE 企业应用开源框架

Spring 的优势

方便解耦，简化开发
通过 Spring 提供的 IOC 容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
AOP 编程的支持
通过 Spring 的 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松应付
声明式事务的支持
可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量
方便程序的测试
可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。
方便集成各种优秀框架
Spring 可以降低各种框架的使用难度，提供了对各种优秀框架（ Struts、 Hibernate、 Hessian、 Quartz等）的直接支持。
降低 JavaEE API 的使用难度
Spring 对 JavaEE API（如 JDBC、 JavaMail、远程调用等）进行了薄薄的封装层，使这些 API 的使用难度大为降低

2、IOC（控制反转）

程序的耦合和解耦

耦合和解耦概念

耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立性)。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。
在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合
分类：
- （1）内容耦合。当一个模块直接修改或操作另一个模块的数据时，或一个模块不通过正常入口而转入另一个模块时，这样的耦合被称为内容耦合。内容耦合是最高程度的耦合，应该避免使用之。
- （2）公共耦合。两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。
- （3）外部耦合。一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传递该全局变量的信息，则称之为外部耦合。
- （4）控制耦合。一个模块通过接口向另一个模块传递一个控制信号，接受信号的模块根据信号值而进行适当的动作，这种耦合被称为控制耦合。
- （5）标记耦合。若一个模块 A 通过接口向两个模块 B 和 C 传递一个公共参数，那么称模块 B 和 C 之间存在一个标记耦合。
- （6）数据耦合。模块之间通过参数来传递数据，那么被称为数据耦合。数据耦合是最低的一种耦合形式，系统中一般都存在这种类型的耦合，因为为了完成一些有意义的功能，往往需要将某些模块的输出数据作为另一些模块的输入数据。
- （7）非直接耦合。两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实现的
总结
耦合是影响软件复杂程度和设计质量的一个重要因素，在设计上我们应采用以下原则：如果模块间必须存在耦合，就尽量使用数据耦合，少用控制耦合，限制公共耦合的范围，尽量避免使用内容耦合
内聚与耦合
- 内聚标志一个模块内各个元素彼此结合的紧密程度，它是信息隐蔽和局部化概念的自然扩展。内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。程序讲究的是低耦合，高内聚。就是同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却要不那么紧密。
- 内聚和耦合是密切相关的，同其他模块存在高耦合的模块意味着低内聚，而高内聚的模块意味着该模块同其他
  模块之间是低耦合。在进行软件设计时，应力争做到高内聚，低耦合

工厂模式解耦

在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。那么，这个读取配置文件，创建和获取三层对象的类就是工厂

实例

properties配置文件

accountService=com.itfzk.service.impl.AccouontServiceImpl
accountDao=com.itfzk.dao.impl.AccountDaoImpl

Bean 对象的工厂模式类

public class BeanFuctory {
    //定义一个 Properties 对象
    private static Properties properties;
    //定义一个 Map，用于存放我们创建的对象，我们称之为容器
    private static Map<String, Object> beans;
    //使用静态代码块对 Properties 对象赋值
    static {
        try {
            //实例化对象
            properties = new Properties();
            //获取 Properties 的流对象
            InputStream inputStream = BeanFuctory.class.getClassLoader().getResourceAsStream("bean.properties");
            properties.load(inputStream);
            //实例化容器对象
            beans = new HashMap<String, Object>();
            //取出配置文件中所有的 key
            Enumeration<Object> keys = properties.keys();
            //遍历枚举
            while (keys.hasMoreElements()){
                //取出每个 key
                String key = keys.nextElement().toString();
                //通过 key 获取 value
                String beanPath = properties.getProperty(key);
                //利用反射机制实例化对象
                Object value = Class.forName(beanPath).newInstance();
                //将 key 和 value 存储在 Map 中
                beans.put(key, value);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 根据 Bean 的名称获取 bean 对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName){
        return beans.get(beanName);
    }
}

IOC 的概念和作用

IOC 控制反转

控制反转(Inversion of Control,英文缩写为IoC)把创建对象的权利交给框架，是框架的重要特征，并非面向对象编程的专用术语。它包括依赖注入(Dependency Injection,简称DI)和依赖查找(Dependency Lookup)。
IoC 的作用：削减计算机程序的耦合(解除我们代码中的依赖关系)

基于 XML 的配置实现 IOC

步骤（四步）

第一步：导入必备的 jar 包到工程中

<dependencies>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-testartifactId>
        <version>5.2.0.RELEASEversion>
        <scope>testscope>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-jdbcartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-txartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>

    <dependency>
        <groupId>org.hamcrestgroupId>
        <artifactId>hamcrest-coreartifactId>
        <version>1.3version>
    dependency>
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
    dependency>

    <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
        <version>5.1.27version>
    dependency>
    <dependency>
        <groupId>commons-dbutilsgroupId>
        <artifactId>commons-dbutilsartifactId>
        <version>1.6version>
    dependency>
    <dependency>
        <groupId>c3p0groupId>
        <artifactId>c3p0artifactId>
        <version>0.9.1.2version>
    dependency>

    <dependency>
        <groupId>cglibgroupId>
        <artifactId>cglibartifactId>
        <version>2.1_3version>
    dependency>

    <dependency>
        <groupId>org.aspectjgroupId>
        <artifactId>aspectjweaverartifactId>
        <version>1.9.5version>
    dependency>
dependencies>

第二步：在 resources 路径下创建一个任意名称的 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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

beans>

第三步：在刚创建的 xml 文件中，配置 spring 管理资源，在配置文件中配置 service 和 dao



<bean id="accountService" class="cn.itfzk.spring.service.impl.AccouontServiceImpl">bean>

<bean id="accountDao" class="cn.itfzk.spring.dao.impl.AccountDaoImpl">bean>

第四步：测试配置是否成功

/**
     * 获取 Spring 的 IOC 核心容器，并根据 id 获取对象
     *
     * ApplicationContext 三种常用实现类
     *      ClassPathXmlApplicationContext ：加载类路径下的配置文件，要求配置文件必须在类路径下，不在的话，加载不了（更常用）
     *      FileSystemXmlApplicationContext ：加载磁盘任意路径下的配置文件（必须有访问权限）
     *      AnnotationConfigApplicationContext ：读取注解创建容器
     * @param args
     */
    public static void main(String[] args) {
        //获取核心容器对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
        //根据 id 获取 Bean 对象
        IAccountService as = (IAccountService) applicationContext.getBean("accountService");
        IAccountDao ad = (IAccountDao) applicationContext.getBean("accountDao");
        System.out.println(as);
        System.out.println(ad);
    }

IOC 中 bean 标签和管理对象

bean 标签

作用：
- 用于配置对象让 spring 来创建的。
- 默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
属性：
- id：给对象在容器中提供一个唯一标识。用于获取对象。
- class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
- scope：指定对象的作用范围。
  - singleton：单例的（默认值）（常用）
  - prototype：多例的（常用）
  - request：作用于 Web 应用的请求范围
  - session：作用于 Web 应用的会话范围
  - global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，他就是 session
- init-method：指定类中的初始化方法名称。
- destroy-method：指定类中销毁方法名称。

配置 bean 标签的属性（xml配置文件）

<bean id="accountService" class="cn.itfzk.spring02.service.impl.AccouontServiceImpl"
          scope="singleton" init-method="init" destroy-method="destroy">bean>

bean 的作用范围和生命周期

单例对象： scope=“singleton”
- 一个应用只有一个对象的实例。它的作用范围就是整个引用。
- 生命周期：
  - init-method：指定类中的初始化方法名称
  - destroy-method：指定类中销毁方法名称
  对象出生：当应用加载，创建容器时，对象就被创建了。
  对象活着：只要容器在，对象一直活着。
  对象死亡：当应用卸载，销毁容器时，对象就被销毁了。
多例对象： scope=“prototype”
- 每次访问对象时，都会重新创建对象实例。
- 生命周期：
  - init-method：指定类中的初始化方法名称
  - destroy-method：指定类中销毁方法名称
  对象出生：当使用对象时，创建新的对象实例。
  对象活着：只要对象在使用中，就一直活着。
  对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了

实例化 Bean 的三种方式

第一种方式：使用默认构造函数创建
在 Spring 的配置文件中使用 Bean 对象，配以 id 和 class 属性之后，且没有其他属性和标签时，采用的就是默认构造函数创建 Bean 对象，此时如果类中没有默认构造函数，则对象无法创建。
```
<bean id="accountService" class="cn.itfzk.spring01.service.impl.AccouontServiceImpl">bean>
```

第二种方式：使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入 Spring 容器）
服务层实现类

public class AccouontServiceImpl {
    public AccouontServiceImpl(String str){
        System.out.println("创建 AccouontServiceImpl 对象");
    }
    public void saveAccount() {
        System.out.println("service 中的 saceAccount 方法执行力。。。");
    }
}

模拟一个工厂类（将这个类看成是 jar 包中的类）

public class InstanceFactory {
    public IAccountService getAccountService(){
        return new AccouontServiceImpl("naem");
    }
}

xml配置文件

<bean id="instanceFactory" class="cn.itfzk.spring01.factory.InstanceFactory" >bean>
<bean id="accountService" factory-bean="instanceFactory" 
      factory-method="getAccountService" >bean>

第三种方法：使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入 Spring 容器）

服务层实现类

public class AccouontServiceImpl {
    public AccouontServiceImpl(String str){
        System.out.println("创建 AccouontServiceImpl 对象");
    }
    public void saveAccount() {
        System.out.println("service 中的 saceAccount 方法执行力。。。");
    }
}

模拟一个工厂类（将这个类看成是 jar 包中的类）

public class StaticFactory {
     //静态方法
    public static IAccountService getAccountService(){
        return new AccouontServiceImpl("naem");
    }
}

xml配置文件

<bean id="accountService" class="cn.itfzk.spring01.factory.StaticFactory" 
      factory-method="getAccountService">bean>

Spring 的依赖注入

依赖注入的概念

依赖注入： Dependency Injection。它是 spring 框架核心 ioc 的具体实现。
注入的数据：三类
- 第一类：基本类型和 String
- 第二类：其他 Bean 类型（在配置文件中或者配置过的 Bean）
- 第三类：复杂类型/集合类型
注入的方式：三种
- 第一种：使用构造函数提供
- 第二种：使用 set 方法提供
- 第三种：使用注解提供

构造函数注入

使用的标签：constructor-arg
标签的位置：bean 标签的内部
标签的属性：
- name：用于指定给构造函数中指定名称的参数赋值（常用的）
- type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
- index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值，索引的位置从 0 开始
- 以上三个用于指定给构造函数中哪个参数赋值
- value：用于提供基本类型和 String 类型的数据
- ref：用于指定其他的 bean 类型数据，它指的就是在 Spring 的 IOC 核心容器中出现过的 bean
对象优势：在获取 Bean 对象时，注入数据是必须的操作，否则对象无法创建成功
弊端：改变了 bean 对象的实例化方式，使我们在创建对象时，如果用不上这些数据，也必须提供

//构造函数注入类
public class AccouontServiceImpl {
    private String name;
    private int age;
    private Date birthday;

    public AccouontServiceImpl(String name, int age, Date birthday) {
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }
}


<bean id="accountService" class="cn.itfzk.spring03.service.impl.AccouontServiceImpl" >
    <constructor-arg name="name" value="fzk" >constructor-arg>
    <constructor-arg name="age" value="20">constructor-arg>
    <constructor-arg name="birthday" ref="now" >constructor-arg> 
bean>

<bean id="now" class="java.util.Date" >bean>

set 方法的注入:（更常用）

使用的标签：property
标签的位置：bean 标签的内部
标签的属性：
- name：用于指定注入时所调用的 set 方法名称
- value：用于提供基本类型和 String 类型的数据
- ref：用于指定其他的 bean 类型数据，它指的就是在 Spring 的 IOC 核心容器中出现过的 bean 对象
优势：创建对象时没有明确的限制，可以直接使用默认构造函数
弊端：如果有某个成员必须有值，则获取对象有可能 set 方法没有执行

//set方法的注入类
public class AccouontServiceImpl01 {
    private String name;
    private int age;
    private Date birthday;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
}


<bean id="accountService01" class="cn.itfzk.spring03.service.impl.AccouontServiceImpl01" >
    <property name="name" value="fzk" >property>
    <property name="age" value="20" >property>
    <property name="birthday" ref="now" >property>
bean>

<bean id="now" class="java.util.Date" >bean>

复杂类型的注入/集合类型的注入

//复杂类型的注入/集合类型的注入
public class AccouontServiceImpl02 implements IAccountService {
    private Object[] myStrs;
    private List<Object> myList;
    private Set<Object> mySet;
    private Map<Object, Object> myMap;
    private Properties myPros;

    public void setMyStrs(Object[] myStrs) {
        this.myStrs = myStrs;
    }

    public void setMyList(List<Object> myList) {
        this.myList = myList;
    }

    public void setMySet(Set<Object> mySet) {
        this.mySet = mySet;
    }

    public void setMyMap(Map<Object, Object> myMap) {
        this.myMap = myMap;
    }

    public void setMyPros(Properties myPros) {
        this.myPros = myPros;
    }
}


<bean id="accountService02" class="cn.itfzk.spring03.service.impl.AccouontServiceImpl02" >
    
    <property name="myStrs" >
        <array>
            <value>fffvalue>
            <value>zzzvalue>
        array>
    property>
    
    
    <property name="myList" >
        <list>
            <value>fffvalue>
            <value>zzzvalue>
        list>
    property>
    
    
    <property name="mySet" >
        <set>
            <value>fffvalue>
            <value>zzzvalue>
        set>
    property>
    
    
    <property name="myMap" >
        <map>
            <entry key="fff" value="fff">entry>
            <entry key="zzz" value="zzz">entry>
        map>
    property>
    
    
    <property name="myPros" >
        <props>
            <prop key="fff">fffprop>
            <prop key="zzz">zzzprop>
        props>
    property>
bean>

使用 spring 的 IoC 的实现账户的CRUD (增删改查)

步骤

创建数据库
编写Javabean类
业务层接口及业务层实现类
持久层接口及持久层实现类
xml 配置文件
测试类

创建数据库

CREATE TABLE `caogao` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) NOT NULL,
  `password` varchar(255) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=latin1;

Javabean类

public class Account implements Serializable {
    private int id;
    private String username;
    private String password;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

业务层接口及业务层实现类

/**
 * 业务层接口
 */
public interface IAccountService {
    //查询所有
    public List<Account> findAll();

    //根据 id 查询信息
    public Account findById(int id);

    //保存信息
    public void save(Account account);

    //修改信息
    public void update(Account account);

    //删除信息
    public void delete(int id);
}

/**
 * 业务层实现类
 */
public class AccountServiceImpl implements IAccountService {
    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

     //查询所有
    public List<Account> findAll() {
        return accountDao.findAll();
    }

    //根据 id 查询信息
    public Account findById(int id) {
        return accountDao.findById(id);
    }

     //保存信息
    public void save(Account account) {
        accountDao.save(account);
    }

    //保存信息
    public void update(Account account) {
        accountDao.update(account);
    }

    //删除信息
    public void delete(int id) {
        accountDao.delete(id);
    }
}

持久层接口及持久层实现类

/**
 * 持久层接口
 */
public interface IAccountDao {
    //查询所有
    public List<Account> findAll();

    //根据 id 查询信息
    public Account findById(int id);

    //保存信息
    public void save(Account account);

    //修改信息
    public void update(Account account);

    //删除信息
    public void delete(int id);
}

/**
 * 持久层实现类
 */
public class AccountDaoImpl implements IAccountDao {
    private QueryRunner queryRunner;

    public void setQueryRunner(QueryRunner queryRunner) {
        this.queryRunner = queryRunner;
    }

    //查询所有
    public List<Account> findAll() {
        List<Account> accounts = null;
        try {
            String sql = "select * from caogao";
           accounts = queryRunner.query(sql, new BeanListHandler<Account>(Account.class));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return accounts;
    }

    //按照id查询
    public Account findById(int id) {
        Account account = null;
        try {
            String sql = "select * from caogao where id=?";
            account = queryRunner.query(sql, new BeanHandler<Account>(Account.class), id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return account;
    }

    //保存信息
    public void save(Account account) {
        try {
            String sql = "insert into caogao(username, password) values(?,?)";
            queryRunner.update(sql, account.getUsername(), account.getPassword());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //修改信息
    public void update(Account account) {
        try {
            String sql = "update caogao set username=?, password=? where id=?";
            queryRunner.update(sql, account.getUsername(), account.getPassword(), account.getId());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //删除信息
    public void delete(int id) {
        try {
            String sql = "delete from caogao where id=?";
            queryRunner.update(sql, id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <bean id="accountService" class="net.memory.Spring01.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao">property>
    bean>

    
    <bean id="accountDao" class="net.memory.Spring01.dao.impl.AccountDaoImpl">
        <property name="queryRunner" ref="queryRunner">property>
    bean>

    
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
        <constructor-arg name="ds" ref="dataSource">constructor-arg>
    bean>

    
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver">property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/fzk">property>
        <property name="user" value="root">property>
        <property name="password" value="123456">property>
    bean>
beans>

测试类

public class accountTest {
    private ApplicationContext applicationContext = new ClassPathXmlApplicationContext("testBean.xml");
    private IAccountService accountService = (IAccountService) applicationContext.getBean("accountService");

    //查询所有测试
    @Test
    public void findAllTest(){
        List<Account> accounts = accountService.findAll();
        for(Account account : accounts){
            System.out.println(account);
        }
    }

    //按照id查询测试
    @Test
    public void findByIdTest(){
        Account account = accountService.findById(2);
        System.out.println(account);
    }

    //保存信息测试
    @Test
    public void saveTest(){
        Account account = new Account();
        account.setUsername("123");
        account.setPassword("123");
        accountService.save(account);
    }

    //修改信息测试
    @Test
    public void update(){
        Account account = new Account(8, "psq", "123");
        accountService.update(account);
    }

    //删除信息测试
    @Test
    public void deleteTest(){
        accountService.delete(8);
    }
}

基于注解的配置实现 IOC

步骤（四步）

第一步：导入必备的 jar 包到工程中

<dependencies>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-testartifactId>
        <version>5.2.0.RELEASEversion>
        <scope>testscope>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-jdbcartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-txartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>

    <dependency>
        <groupId>org.hamcrestgroupId>
        <artifactId>hamcrest-coreartifactId>
        <version>1.3version>
    dependency>
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
    dependency>

    <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
        <version>5.1.27version>
    dependency>
    <dependency>
        <groupId>commons-dbutilsgroupId>
        <artifactId>commons-dbutilsartifactId>
        <version>1.6version>
    dependency>
    <dependency>
        <groupId>c3p0groupId>
        <artifactId>c3p0artifactId>
        <version>0.9.1.2version>
    dependency>

    <dependency>
        <groupId>cglibgroupId>
        <artifactId>cglibartifactId>
        <version>2.1_3version>
    dependency>

    <dependency>
        <groupId>org.aspectjgroupId>
        <artifactId>aspectjweaverartifactId>
        <version>1.9.5version>
    dependency>
dependencies>

第二步：使用@Component 注解配置管理的资源

@Component("accountService")
public class AccountServiceImpl implements IAccountService {
    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }
}

第三步：创建 spring 的 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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
    
    <context:component-scan base-package="net.memory">context:component-scan>
beans>

第四步：测试配置是否成功

public class Client {
    public static void main(String[] args) {
        ApplicationContext application = new ClassPathXmlApplicationContext("testBean.xml");
        IAccountService accountService = (IAccountService) application.getBean("accountService");
        System.out.println(accountService);
    }
}

常用注解

用于创建对象

相当于 xml：
@Component
- 作用：用于把当前类对象存入 Spring 容器中
- 属性：
  - value：用于指定 Bean 的 id，当我们不写时，他的默认值是当前类名，且首字母改小写
@Controller @Service @Repository
- 作用和属性与 @Component 是一模一样的，他们三个是 Spring 框架为我们提供明确的三层架构使用的注解，使我们的三层架构对象更加清晰
- @Controller：一般用在表现层
- @Service：一般用在业务层
- @Repository：一般用在持久层

用于改变作用范围

相当于xml： scope="">
@Scope:
- 作用：用于指定 bean 的作用范围
- 属性：
  - value：指定范围的取值。常用取值：singleton（单例，默认） prototype（多例）

和生命周期相关

相当于xml： init-method="" destroy-method="" />
@PostConstruct
- 作用：用于指定初始化方法
@PreDestroy
- 作用：用于指定销毁方法

用于注入数据

相当于xml：
@Autowired
作用：自动按照类型注入，只要容器中有唯一的一个 Bean 对象类型和要注入的变量类型匹配，就注入成功如果 IOC 容器中没有任何 Bean 类型和要注入的变量类型匹配则报错
- 出现位置：可以是变量上，也可以是方法上
- 细节：在使用注解注入时，set 方法不是必须的
@Qualifier
作用：在按照类中注入的基础之上再按照名称注入。它在给类成员注入时不能单独使用，但是在给方法参数注入时可以
- 属性：
  - value：用于指定注入 bean 的 id
@Resource
作用：直接按照 bean 的 id 注入，可以单独使用
- 属性：
  - name：用于指定 bean 的 id
以上三个注解都只能注入其他 bean 类型的数据，而基本类型和 String 类型无法使用，另外，集合类型的注入只能通过 XML 来实现
@Value()
作用：用于注入基本类型和 String 类型
- 属性：
  - value：用于指定数据的值，它可以使用 Spring 中的 SpEL（Spring 的 EL 表达式）
    - SpEL的写法：${表达式}

Spring 注解和 XML 的选择问题

注解的优势：
- 配置简单，维护方便（我们找到类，就相当于找到了对应的配置）。
XML 的优势：
- 修改时，不用改源码。不涉及重新编译和部署。

Spring 管理 Bean 方式的比较：

	基于XML配置	基于注解配置
Bean定义		@Component 衍生类@Repository @Service @Controller
Bean名称	通过id或name指定	@Component("**")
Bean注入	或	@Autowired 按类型注入 @Qualifer 按名称注入 @Resource 按bean的id注入 @Value 注入基本类型和 String 类型
生命过程、Bean作用范围	init-method destroy-method 范围scope属性	@PostConstruct初始化 @PreDestroy 销毀 @Scope设置作用范围
适合场景	Bean来自第三方，使用其它	Bean的实现类由用户自己开发

Spring 的纯注解配置

@Configuration
- 作用：
  - 用于指定当前类是一个 spring 配置类，当创建容器时会从该类上加载注解。
  - 获取容器时需要使用 AnnotationApplicationContext (有@Configuration 注解的类.class)。
- 属性：
  - value:用于指定配置类的字节码
```
//该类是一个 spring 配置类
@Configuration
public class Config {
}
```
@ComponentScan
- 相当于xml：
- 作用：
  - 用于指定 spring 在初始化容器时要扫描的包
- 属性：
  - basePackages：用于指定要扫描的包。和该注解中的 value 属性作用一样
```
//扫描指定的包：cn.itfzk.spring05
@Configuration
@ComponentScan(basePackages = {"cn.itfzk.spring05"})
public class Config {
}
```

@Bean

作用：用于把当前方法的返回值作为 bean 对象存入 Spring 的 IOC 容器中
属性：
- name：用于指定 bean 的 id。当不写时，默认值是当前方法的名称
细节：
- 当我们使用注解配置方法时，如果方法有参数，Spring 框架会去容器中查找有没有可以用的 bean 对象，查找的方式和 Autowired 注解的作用是一样的

public class JdbcConfig {
    /**
     * 创建 QueryRunner 对象
     * @param dataSource
     * @return
     * @Bean(name = "runner") 和 createQueryRunner 方法相当于：
     * 
     *      
     * 
     */
    @Bean(name = "queryRunner")
    public QueryRunner createQueryRunner(DataSource dataSource){
        return new QueryRunner(dataSource);
    }

    /**
     * 创建 DataSource 对象
     * @return
     * @Bean(name = "dataSource") 和 createDataSource 方法相当于：
     * 
     *      
     *      
     *      
     *      
     * 
     */
    @Bean(name = "dataSource")
    public DataSource createDataSource(){
        ComboPooledDataSource ds = new ComboPooledDataSource();
        try {
            ds.setDriverClass("com.mysql.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/fzk");
            ds.setUser("root");
            ds.setPassword("123456");
        } catch (PropertyVetoException e) {
            e.printStackTrace();
        }
        return ds;
    }
}

@Import
- 作用：用于导入其他配置的类
- 属性：
  - value[]：用于指定其他配置类的字节码
- 细节：当我们使用 @Import 注解之后，有 @Import 注解的类就是父配置类，而导入的都是子类配置
```
@Configuration
@Import(value = {JdbcConfig.class})  //用于导入其他配置的类
public class Config {
}
```

@PropertySource

作用：用于加载.properties 文件中的配置
属性：
- value[]：用于指定 properties 文件位置。如果是在类路径下，需要写上 classpath:

//properties 文件中的配置
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/fzk
jdbc.name=root
jdbc.password=123456

@Configuration
@PropertySource(value = {"classpath:jdbc.properties"})  //加载 properties 文件中的配置
public class Config {
    @Value("${jdbc.driver}")  //取出 properties 文件中的 jdbc.driver 数据
    private String driver;
}

通过注解获取容器

ApplicationContext application = new AnnotationConfigApplicationContext(SpringConfiguration.class);

3、Spring 整合 Junit

步骤（四步）

第一步：导入必备的 jar 包到工程中

<dependencies>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-testartifactId>
        <version>5.2.0.RELEASEversion>
        <scope>testscope>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-jdbcartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-txartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>

    <dependency>
        <groupId>org.hamcrestgroupId>
        <artifactId>hamcrest-coreartifactId>
        <version>1.3version>
    dependency>
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
    dependency>

    <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
        <version>5.1.27version>
    dependency>
    <dependency>
        <groupId>commons-dbutilsgroupId>
        <artifactId>commons-dbutilsartifactId>
        <version>1.6version>
    dependency>
    <dependency>
        <groupId>c3p0groupId>
        <artifactId>c3p0artifactId>
        <version>0.9.1.2version>
    dependency>

    <dependency>
        <groupId>cglibgroupId>
        <artifactId>cglibartifactId>
        <version>2.1_3version>
    dependency>

    <dependency>
        <groupId>org.aspectjgroupId>
        <artifactId>aspectjweaverartifactId>
        <version>1.9.5version>
    dependency>
dependencies>

第二步：使用@RunWith 注解替换原有运行器

@RunWith(SpringJUnit4ClassRunner.class)  //替换原有运行器  
public class accountTest {
}

第三步：使用@ContextConfiguration 指定 spring 配置文件的位置

xml 方法来指定 spring 配置文件的位置

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:testBean.xml")  //指定 spring 配置文件的位置 
public class accountTest {

注解方法来指定 spring 配置文件的位置

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)  //指定 spring 配置文件的位置 
public class accountTest {

第四步：使用@Autowired 给测试类中的变量注入数据

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
@ContextConfiguration(locations = "classpath:testBean.xml")
public class accountTest {
    @Autowired  //给测试类中的变量注入数据   
    private IAccountService accountService;
}

4、AOP（面向切面编程）

AOP 概述

AOP 概念

AOP：全称是 Aspect Oriented Programming（面向切面编程)
把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。

AOP 的作用及优势

作用：
- 在程序运行期间，不修改源码对已有方法进行增强。
优势：
- 减少重复代码
- 提高开发效率
- 维护方便

动态代理技术实现（CRUD）

业务层（接口，类）

//业务层接口
public interface IAccountService {
    //查询所有
    List<Account> findAll();

    //按 id 查询
    Account findById(int id);

    //按 username 查询
    Account findByName(String username);

    //添加信息
    void saveAccount(Account account);

    //修改信息
    void updateAccount(Account account);

    //按 id 删除信息
    void deleteById(int id);

    //交换信息
    void changeMessage(String username1, String username2);
}



//业务层实现类
public class AccountServiceImpl implements IAccountService {
    private AccountDaoImpl accountDao;

    public void setAccountDao(AccountDaoImpl accountDao) {
        this.accountDao = accountDao;
    }

    //查询所有信息
    public List<Account> findAll() {
        return accountDao.findAll();
    }

    //按 id 查询信息
    public Account findById(int id) {
        return accountDao.findById(id);
    }

    //按 username 查询信息
    public Account findByName(String username) {
        return accountDao.findByName(username);
    }

    //添加信息
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    //修改信息=
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    //删除信息=
    public void deleteById(int id) {
        accountDao.deleteById(id);
    }

    //交换信息，将 username1 和 username2 的名字交换=
    public void changeMessage(String username1, String username2) {
        accountDao.changeMessage(username1, username2);
    }
}

//持久层接口
public interface IAccountDao {
    //查询所有
    List<Account> findAll();

    //按 id 查询
    Account findById(int id);

    //按 username 查询
    Account findByName(String username);

    //添加信息
    void saveAccount(Account account);

    //修改信息
    void updateAccount(Account account);

    //按 id 删除信息
    void deleteById(int id);

    //交换信息
    void changeMessage(String username1, String username2);
}


//持久层实现类
public class AccountDaoImpl implements IAccountService {
    private QueryRunner queryRunner;
    private ConnectionUtils connectionUtils;

    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    public void setQueryRunner(QueryRunner queryRunner) {
        this.queryRunner = queryRunner;
    }

    //查询所有信息
    public List<Account> findAll() {
        try {
            return queryRunner.query(connectionUtils.getThreadConnection() ,"select * from caogao", new BeanListHandler<Account>(Account.class));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    //按 id 查询信息
    public Account findById(int id) {
        try {
            return queryRunner.query(connectionUtils.getThreadConnection() ,"select * from caogao where id=?", new BeanHandler<Account>(Account.class), id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    //按 username 查询信息
    public Account findByName(String username) {
        try {
            return queryRunner.query(connectionUtils.getThreadConnection() ,"select * from caogao where username=?", new BeanHandler<Account>(Account.class), username);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    //添加信息
    public void saveAccount(Account account) {
        try {
            queryRunner.update(connectionUtils.getThreadConnection() ,"insert into caogao(username, password) values(?,?)", account.getUsername(), account.getPassword());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //修改信息
    public void updateAccount(Account account) {
        try {
            queryRunner.update(connectionUtils.getThreadConnection() ,"update caogao set username=?, password=? where id=?", account.getUsername(), account.getPassword(), account.getId());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //删除信息
    public void deleteById(int id) {
        try {
            queryRunner.update(connectionUtils.getThreadConnection() ,"delete from caogao where id=?", id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //交换信息，将 username1 和 username2 的信息交换
    public void changeMessage(String username1, String username2) {
        //1、查询 username1 的信息
        Account user1 = findByName(username1);
        //2、查询 username2 的信息
        Account user2 = findByName(username2);
        //3、修改 username1 的信息
        user1.setUsername(username2);
        //4、修改 username2 的信息
        user2.setUsername(username1);
        //5、更新 username1 的信息
        updateAccount(user1);
        //模拟网络错误
        int i = 10 / 0;
        //6、更新 username2 的信息
        updateAccount(user2);
    }
}

连接的工具类

public class ConnectionUtils {
    private ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();
    private DataSource dataSource;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    //获取连接
    public Connection getThreadConnection(){
        //从 ThreadLocal 获取连接
        Connection connection = threadLocal.get();
        //判断是否有连接
        if(connection == null){
            try {
                //从数据源中获取一个连接，并存入 ThreadLocal 中
                connection = dataSource.getConnection();
                threadLocal.set(connection);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return connection;
    }

    //把连接和线程解绑
    public void removeConnection(){
        threadLocal.remove();
    }
}

事务相关的工具类

public class TransactionManager {
    private ConnectionUtils connectionUtils;

    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    /**
     * 开启事务
     */
    public void beginTransation(){
        try {
            connectionUtils.getThreadConnection().setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 提交事务
     */
    public void commit(){
        try {
            connectionUtils.getThreadConnection().commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 回滚事务
     */
    public void rollback(){
        try {
            connectionUtils.getThreadConnection().rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 释放事务
     */
    public void close(){
        try {
            connectionUtils.getThreadConnection().close();  //还回线程池
            connectionUtils.removeConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

AccountServiceImpl 的代理工厂类

public class BeanFactory {
    private IAccountService accountService;
    private TransactionManager transactionManager;

    public void setTransactionManager(TransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    public void setAccountService(IAccountService accountService) {
        this.accountService = accountService;
    }

    public IAccountService getAccountService() {
        return (IAccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
                accountService.getClass().getInterfaces(),
                new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object invoke;
                        try {
                            //1、开启事务
                            transactionManager.beginTransation();
                            //2、执行操作
                            invoke = method.invoke(accountService, args);
                            //3、提交事务
                            transactionManager.commit();
                            //4、返回结果
                            return invoke;
                        }catch (Exception e){
                            //5、回滚事务
                            transactionManager.rollback();
                            throw new RuntimeException(e);
                        }finally{
                            //6、释放连接
                            transactionManager.close();
                        }
                    }
                });
    }
}

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    
    <bean id="accountService" class="itfzk.project.service.impl.AccountServiceImpl" >
        <property name="accountDao" ref="accountDao" >property>
    bean>
    
    <bean id="accountDao" class="itfzk.project.dao.impl.AccountDaoImpl" >
        <property name="queryRunner" ref="queryRunner" >property>
        <property name="connectionUtils" ref="connectionUtils" >property>
    bean>
    
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype" >
    bean>
    
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >
        <property name="driverClass" value="com.mysql.jdbc.Driver" >property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/fzk" >property>
        <property name="user" value="root" >property>
        <property name="password" value="123456" >property>
    bean>
    
    <bean id="connectionUtils" class="itfzk.project.utils.ConnectionUtils" >
        <property name="dataSource" ref="dataSource" >property>
    bean>
    
    <bean id="transactionManager" class="itfzk.project.utils.TransactionManager" >
        <property name="connectionUtils" ref="connectionUtils" >property>
    bean>
    
    <bean id="beanFactory" class="itfzk.project.factory.BeanFactory" >
        <property name="accountService" ref="accountService" >property>
        <property name="transactionManager" ref="transactionManager" >property>
    bean>
    
    <bean id="accountDaoImpl_BeanFactory" factory-bean="beanFactory" factory-method="getAccountService" >bean>
beans>

Spring 中的 AOP

AOP 相关术语

Joinpoint(连接点):
- 所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。
Pointcut(切入点):
- 所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
Advice(通知/增强):
- 所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
- 通知的类型：
  - 前置通知,后置通知,异常通知,最终通知,环绕通知。
Introduction(引介):
- 引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。
Target(目标对象):
- 代理的目标对象。
Weaving(织入):
- 是指把增强应用到目标对象来创建新的代理对象的过程。
- spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
Proxy（代理） :
- 一个类被 AOP 织入增强后，就产生一个结果代理类。
Aspect(切面):
- 是切入点和通知（引介）的结合

基于 XML 的 AOP 配置

步骤（七步）

第一步：导入必备的 jar 包到工程中

<dependencies>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-testartifactId>
        <version>5.2.0.RELEASEversion>
        <scope>testscope>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-jdbcartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-txartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>

    <dependency>
        <groupId>org.hamcrestgroupId>
        <artifactId>hamcrest-coreartifactId>
        <version>1.3version>
    dependency>
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
    dependency>

    <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
        <version>5.1.27version>
    dependency>
    <dependency>
        <groupId>commons-dbutilsgroupId>
        <artifactId>commons-dbutilsartifactId>
        <version>1.6version>
    dependency>
    <dependency>
        <groupId>c3p0groupId>
        <artifactId>c3p0artifactId>
        <version>0.9.1.2version>
    dependency>

    <dependency>
        <groupId>cglibgroupId>
        <artifactId>cglibartifactId>
        <version>2.1_3version>
    dependency>

    <dependency>
        <groupId>org.aspectjgroupId>
        <artifactId>aspectjweaverartifactId>
        <version>1.9.5version>
    dependency>
dependencies>

第二步：创建 spring 的配置文件并导入约束


<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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd">

beans>

第三步：把通知类用 bean 标签配置起来


<bean id="txManager" class="cn.itfzk.spring07.log.Logger">bean>

第四步：使用 aop:config 声明 aop 配置
```
<aop:config>
    
aop:config>
```

第五步：使用 aop:aspect 配置切面

<aop:config>
    <aop:aspect id="txAdvice" ref="txManager">
        
    aop:aspect>
aop:config>

第六步：使用 aop:pointcut 配置切入点表达式

<aop:aspect id="txAdvice" ref="txManager">
    <aop:pointcut id="pt1" expression="execution(* cn.itfzk.spring07.service.impl.AccountServiceImpl.save())"/>
aop:aspect>

第七步：使用 aop:xxx 配置对应的通知类型

<aop:pointcut id="pt1" expression="execution(* cn.itfzk.spring07.service.impl.AccountServiceImpl.save())"/>
<aop:before method="beforeLog" pointcut-ref="pt1">aop:before>
<aop:after-returning method="afterReturningLog" pointcut-ref="pt1">aop:after-returning>
<aop:after-throwing method="afterThrowingLog"  pointcut-ref="pt1">aop:after-throwing>
<aop:after method="afterLog" pointcut-ref="pt1">aop:after>

aop:config

作用：用于声明开始 aop 的配置
```
<aop:config>
    
aop:config>
```

aop:aspect

作用：
- 用于配置切面。

属性：

id：给切面提供一个唯一标识。
ref：引用配置好的通知类 bean 的 id。

<aop:config>
    <aop:aspect id="txAdvice" ref="txManager">
        
    aop:aspect>
aop:config>

aop:before、aop:after-returning、aop:after-throwing、aop:after

aop:before ：配置前置通知
aop:after-returning ：配置后置通知
aop:after-throwing ：配置异常通知
aop:after ：配置最终通知
以上四个标签的属性：
- method 属性：用于指定前置通知类的方法
- pointcut 属性：用于指定切入点的表达式
  - pointcut 属性切入点表达式的写法：
    - 关键字：execution
    - 标准写法：
      - 方法类型包名.类名.方法名(参数)
        void(int | String | …) cn.itfzk.spring07.service.impl.AccountServiceImpl.save(…)
    - 全通配写法(* 代表任意)：
```
* *..*.*(..)
```
不使用 aop:pointcut



<aop:before method="beforeLog" pointcut="execution(* cn.itfzk.spring07.service.impl.AccountServiceImpl.save())">aop:before>


<aop:after-returning method="afterReturningLog"  pointcut="execution(* cn.itfzk.spring07.service.impl.AccountServiceImpl.save())">aop:after-returning>


<aop:after-throwing method="afterThrowingLog" pointcut="execution(* cn.itfzk.spring07.service.impl.AccountServiceImpl.save())">aop:after-throwing>


<aop:after method="afterLog"  pointcut="execution(* cn.itfzk.spring07.service.impl.AccountServiceImpl.save())">aop:after>

使用 aop:pointcut

<aop:pointcut id="pt1" expression="execution(* cn.itfzk.spring07.service.impl.AccountServiceImpl.save())"/>

<aop:before method="beforeLog" pointcut-ref="pt1">aop:before>


<aop:after-returning method="afterReturningLog" pointcut-ref="pt1">aop:after-returning>


<aop:after-throwing method="afterThrowingLog"  pointcut-ref="pt1">aop:after-throwing>


<aop:after method="afterLog" pointcut-ref="pt1">aop:after>

aop:around（环绕通知）

作用：
- 用于配置环绕通知
属性：
- method：指定通知中方法的名称。
- pointct：定义切入点表达式
- pointcut-ref：指定切入点表达式的引用
说明：
- 它是 spring 框架为我们提供的一种可以在代码中手动控制增强代码什么时候执行的方式。

注意：

通常情况下，环绕通知都是独立使用的


<aop:config>
        <aop:aspect id="txAdvice" ref="transactionManaget">
            <aop:pointcut id="pt" expression="execution(* net.memory.Spring01.service.impl.AccountServiceImpl.*(..))"/>
            
            <aop:around method="aroundAccount" pointcut-ref="pt">aop:around>
        aop:aspect>
    aop:config>

//环绕通知实现方法
public Object aroundAccount(ProceedingJoinPoint proceedingJoinPoint){
    Object proceed = null;
    try {
        //前置通知
        beginTransaction();
        Object[] args = proceedingJoinPoint.getArgs();
        proceed = proceedingJoinPoint.proceed();
        //后置通知
        commit();
    } catch (Throwable throwable) {
        //异常通知
        rollback();
        throwable.printStackTrace();
    } finally {
        //最终通知
        close();
    }
    return proceed;
}

aop:pointcut

作用：
- 用于配置切入点表达式。就是指定对哪些类的哪些方法进行增强

属性：

id：用于给切入点表达式提供一个唯一标识
expression：用于定义切入点表达式

<aop:pointcut id="pt1" expression="execution(* cn.itfzk.spring07.service.impl.AccountServiceImpl.save())"/>

基于注解的 AOP 配置

步骤（八步）

第一步：导入必备的 jar 包到工程中

<dependencies>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-testartifactId>
        <version>5.2.0.RELEASEversion>
        <scope>testscope>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-jdbcartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-txartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>

    <dependency>
        <groupId>org.hamcrestgroupId>
        <artifactId>hamcrest-coreartifactId>
        <version>1.3version>
    dependency>
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
    dependency>

    <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
        <version>5.1.27version>
    dependency>
    <dependency>
        <groupId>commons-dbutilsgroupId>
        <artifactId>commons-dbutilsartifactId>
        <version>1.6version>
    dependency>
    <dependency>
        <groupId>c3p0groupId>
        <artifactId>c3p0artifactId>
        <version>0.9.1.2version>
    dependency>

    <dependency>
        <groupId>cglibgroupId>
        <artifactId>cglibartifactId>
        <version>2.1_3version>
    dependency>

    <dependency>
        <groupId>org.aspectjgroupId>
        <artifactId>aspectjweaverartifactId>
        <version>1.9.5version>
    dependency>
dependencies>

第二步：创建 spring 的配置文件并导入约束


<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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd">

beans>

第三步：把资源使用注解配置

@Service("accountService")
public class AccountServiceImpl implements IAccountService {
}

第四步：在配置文件中指定 spring 要扫描的包


<context:component-scan base-package="net.memory">context:component-scan>

第五步：把通知类也使用注解配置 @Component

@Component("transactionManager")  //使用注解配置
public class TransactionManager {
}

第六步：在通知类上使用 @Aspect 注解声明为切面

@Component("transactionManager")  
@Aspect  //使用@Aspect 注解声明为切面  
public class TransactionManager {
}

第七步：在增强的方法上使用注解配置通知

@Before、@AfterReturning、@AfterThrowing、@After（前置、后置、异常、最终通知）

@Component("transactionManaget")
@Aspect
public class TransactionManaget {
    @Autowired
    private ConnectionUtils connectionUtils;

    //前置通知
    @Before("execution(* net.memory.Spring01.service.impl.AccountServiceImpl.*(..))")
    public void beginTransaction(){
        try {
            connectionUtils.getConnection().setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //后置通知
    @AfterReturning("execution(* net.memory.Spring01.service.impl.AccountServiceImpl.*(..))")
    public void commit(){
        try {
            connectionUtils.getConnection().commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //异常通知
    @AfterThrowing("execution(* net.memory.Spring01.service.impl.AccountServiceImpl.*(..))")
    public void rollback(){
        try {
            connectionUtils.getConnection().rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //最终通知
    @After("execution(* net.memory.Spring01.service.impl.AccountServiceImpl.*(..))")
    public void close(){
        try {
            connectionUtils.getConnection().close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        connectionUtils.removeConnection();
    }
}

@Around（环绕通知）

@Component("transactionManaget")
@Aspect
public class TransactionManaget {
    @Autowired
    private ConnectionUtils connectionUtils;

    //前置通知
    public void beginTransaction(){
        try {
            connectionUtils.getConnection().setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //后置通知
    public void commit(){
        try {
            connectionUtils.getConnection().commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //异常通知
    public void rollback(){
        try {
            connectionUtils.getConnection().rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //最终通知
    public void close(){
        try {
            connectionUtils.getConnection().close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        connectionUtils.removeConnection();
    }
    
    //环绕通知
    @Around("execution(* net.memory.Spring01.service.impl.AccountServiceImpl.*(..))")
    public Object aroundAccount(ProceedingJoinPoint proceedingJoinPoint){
        Object proceed = null;
        try {
            beginTransaction();  //前置通知
            Object[] args = proceedingJoinPoint.getArgs();
            proceed = proceedingJoinPoint.proceed();
            commit();  //后置通知 
        } catch (Throwable throwable) {
            rollback();  //异常通知
            throwable.printStackTrace();
        } finally {
            close();  //最终通知
        }
        return proceed;
    }
}

第八步：在 spring 配置文件中开启 spring 对注解 AOP 的支持

<context:component-scan base-package="net.memory">context:component-scan>

<aop:aspectj-autoproxy />

注解

@Aspect

作用：

把当前类声明为切面类。

@Component("transactionManager")  
@Aspect  //使用@Aspect 注解声明为切面  
public class TransactionManager {
}

@Before 、 @AfterReturning 、 @AfterThrowing 、@After

@Before ：把当前方法看成是前置通知。
@AfterReturning ：把当前方法看成是后置通知。
@AfterThrowing ：把当前方法看成是异常通知。

@After ：把当前方法看成是最终通知

@Before("execution(* net.memory.Spring01.service.impl.AccountServiceImpl.*(..))")
@AfterReturning("execution(* net.memory.Spring01.service.impl.AccountServiceImpl.*(..))")
@AfterThrowing("execution(* net.memory.Spring01.service.impl.AccountServiceImpl.*(..))")
@After("execution(* net.memory.Spring01.service.impl.AccountServiceImpl.*(..))")

@Around

作用：

把当前方法看成是环绕通知

@Around("execution(* net.memory.Spring01.service.impl.AccountServiceImpl.*(..))")

@Pointcut

作用：指定切入点表达式

属性：

value：指定表达式的内容

@Pointcut("execution(* net.memory.Spring01.service.impl.AccountServiceImpl.*(..))")
public void pt1(){
}

@Before("pt1()")
@AfterReturning("pt1()")
@AfterThrowing("pt1()")
@After("pt1()")

@Around("pt1()")

@EnableAspectJAutoProxy（纯注解的配置方式）

@Configuration
@ComponentScan(basePackages = {"net.memory"})  //扫描指定的包：cn.itfzk.spring05
@Import(JdbcConfiguration.class)
@EnableAspectJAutoProxy  //开启 spring 对注解 AOP 的支持
public class SpringConfiguration {
}

5、Spring 中的 JdbcTemplate

概述

spring 框架中提供的一个对象，是对原始 Jdbc API 对象的简单封装。
spring 框架为我们提供了很多的操作模板类。
- 操作关系型数据的：
  - JdbcTemplate
  - HibernateTemplate
- 操作 nosql 数据库的：
  - RedisTemplate
- 操作消息队列的：
  - JmsTemplate

JdbcTemplate 的增删改查操作

不在 dao 中使用 JdbcTemplate

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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd">

    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource">property>
    bean>

    
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver">property>
        <property name="url" value="jdbc:mysql://localhost:3306/fzk">property>
        <property name="username" value="root">property>
        <property name="password" value="123456">property>
    bean>
beans>

JdbcTemplate使用类

public class JdbcTemplateDemo {
    private ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean08.xml");
    private JdbcTemplate jdbcTemplate = (JdbcTemplate) applicationContext.getBean("jdbcTemplate");

    /**
     * 查询所有
     */
    @Test
    public void findAll(){
        String sql = "select * from caogao";
        List<Account> accounts = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Account>(Account.class));
        for(Account account : accounts){
            System.out.println(account);
        }
    }

    /**
     * 获取其他类型的数据
     */
    @Test
    public void find(){
        String sql = "select count(*) from caogao";
        Long fzk = jdbcTemplate.queryForObject(sql, Long.class);
        System.out.println(fzk);
    }

    /**
     * 按条件查询
     */
    @Test
    public void findById(){
        String sql = "select * from caogao where id = ?";
        List<Account> accounts = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Account>(Account.class), 2);
        System.out.println(accounts.get(0));
    }

    /**
     * 修改
     */
    @Test
    public void updateById(){
        String sql = "update caogao set username = ?, password = ? where id = ?";
        jdbcTemplate.update(sql, "fff123", "fff123", 2);
    }

    /**
     * 添加信息
     */
    @Test
    public void add(){
        String sql = "insert into caogao(username, password) values(?,?)";
        jdbcTemplate.update(sql, "psq", "123");
    }

    /**
     * 删除信息
     */
    @Test
    public void delete(){
        String sql = "delete from caogao where id = ?";
        jdbcTemplate.update(sql, 7);
    }
}

在 dao 中使用 JdbcTemplate

方法一

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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd">

    <bean id="jdbcTemplateDemo" class="cn.itfzk.spring08.JdbcTemplateDemo">
        <property name="jdbcTemplate" ref="jdbcTemplate">property>
    bean>

    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource">property>
    bean>

    
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver">property>
        <property name="url" value="jdbc:mysql://localhost:3306/fzk">property>
        <property name="username" value="root">property>
        <property name="password" value="123456">property>
    bean>
beans>

JdbcTemplate使用类

public class JdbcTemplateDemo {
    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    /**
     * 查询所有
     */
    public List<Account> findAll(){
        String sql = "select * from caogao";
        List<Account> accounts = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Account>(Account.class));
        return accounts;
    }

    /**
     * 获取其他类型的数据
     */
    public Integer find(){
        String sql = "select count(*) from caogao";
        Integer fzk = jdbcTemplate.queryForObject(sql, Long.class);
        return fzk;
    }

    /**
     * 按条件查询
     */
    public Account findById(){
        String sql = "select * from caogao where id = ?";
        List<Account> accounts = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Account>(Account.class), 2);
        return accounts.get(0);
    }

    /**
     * 修改
     */
    public void updateById(){
        String sql = "update caogao set username = ?, password = ? where id = ?";
        jdbcTemplate.update(sql, "fff123", "fff123", 2);
    }

    /**
     * 添加信息
     */
    public void add(){
        String sql = "insert into caogao(username, password) values(?,?)";
        jdbcTemplate.update(sql, "psq", "123");
    }

    /**
     * 删除信息
     */
    public void delete(){
        String sql = "delete from caogao where id = ?";
        jdbcTemplate.update(sql, 7);
    }
}

方法二：让 dao 继承 JdbcDaoSupport

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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd">

    <bean id="jdbcTemplateDemo" class="cn.itfzk.spring08.JdbcTemplateDemo">
        <property name="dataSource" ref="dataSource">property>
    bean>

    
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver">property>
        <property name="url" value="jdbc:mysql://localhost:3306/fzk">property>
        <property name="username" value="root">property>
        <property name="password" value="123456">property>
    bean>
beans>

继承JdbcDaoSupport类

public class JdbcTemplateDemo extends JdbcDaoSupport {
    /**
     * 查询所有
     */
    public List<Account> findAll(){
        String sql = "select * from caogao";
        List<Account> accounts = getJdbcTemplate().query(sql, new BeanPropertyRowMapper<Account>(Account.class));
        return accounts;
    }

    /**
     * 获取其他类型的数据
     */
    public Integer find(){
        String sql = "select count(*) from caogao";
        Integer fzk = getJdbcTemplate().queryForObject(sql, Long.class);
        return fzk;
    }

    /**
     * 按条件查询
     */
    public Account findById(){
        String sql = "select * from caogao where id = ?";
        List<Account> accounts = getJdbcTemplate().query(sql, new BeanPropertyRowMapper<Account>(Account.class), 2);
        return accounts.get(0);
    }

    /**
     * 修改
     */
    public void updateById(){
        String sql = "update caogao set username = ?, password = ? where id = ?";
        getJdbcTemplate().update(sql, "fff123", "fff123", 2);
    }

    /**
     * 添加信息
     */
    public void add(){
        String sql = "insert into caogao(username, password) values(?,?)";
        getJdbcTemplate().update(sql, "psq", "123");
    }

    /**
     * 删除信息
     */
    public void delete(){
        String sql = "delete from caogao where id = ?";
        getJdbcTemplate().update(sql, 7);
    }
}

6、Spring 中的事务控制

Spring 中事务控制的 API 介绍

事务的隔离级别

ISOLATION DEFAULT
- 默认级别，归属下列某一种
ISOLATION READ UNCOMMITTED
- 可以读取未提交数据
ISOLATION READ_ COMMITTED
- 只能读取已提交数据，解决脏读问题(Oracle默认级别)
ISOLATION REPEATABLE READ
- 是否读取其他事务提交修改后的数据，解决不可重复读问题(MySQL默认级别)
ISOLATION SERIALIZABLE
- 是否读取其他事务提交添加后的数据，解决幻影读问题

事务的传播行为

REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在事务，加入到这个事务中。增删改的选择
SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务）查询可以的选择
MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常
REQUERS_NEW：新建事务，如果当前在事务中，把当前事务挂起。
NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
NEVER：以非事务方式运行，如果当前存在事务，抛出异常
NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行 REQUIRED 类似的操作。

超时时间

默认值是-1，没有超时限制。如果有，以秒为单位进行设置。

是否是只读事务

建议查询时设置为只读。

基于 XML 的声明式事务控制

步骤（十步）

第一步：导入必备的 jar 包到工程中

<dependencies>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-testartifactId>
        <version>5.2.0.RELEASEversion>
        <scope>testscope>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-jdbcartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-txartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>

    <dependency>
        <groupId>org.hamcrestgroupId>
        <artifactId>hamcrest-coreartifactId>
        <version>1.3version>
    dependency>
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
    dependency>

    <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
        <version>5.1.27version>
    dependency>
    <dependency>
        <groupId>commons-dbutilsgroupId>
        <artifactId>commons-dbutilsartifactId>
        <version>1.6version>
    dependency>
    <dependency>
        <groupId>c3p0groupId>
        <artifactId>c3p0artifactId>
        <version>0.9.1.2version>
    dependency>

    <dependency>
        <groupId>cglibgroupId>
        <artifactId>cglibartifactId>
        <version>2.1_3version>
    dependency>

    <dependency>
        <groupId>org.aspectjgroupId>
        <artifactId>aspectjweaverartifactId>
        <version>1.9.5version>
    dependency>
dependencies>

第二步：创建 spring 的配置文件并导入约束


<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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd">

beans>

第三步：编写业务层接口和实现类

//业务层接口
public interface IAccountService {
    //查询所有
    List<Account> findAll();

    //按 id 查询
    Account findById(int id);

    //按 username 查询
    Account findByName(String username);

    //添加信息
    void saveAccount(Account account);

    //修改信息
    void updateAccount(Account account);

    //按 id 删除信息
    void deleteById(int id);

    //交换信息
    void changeMessage(String username1, String username2);
}


//业务层实现类
public class AccountServiceImpl implements IAccountService {
    private AccountDaoImpl accountDao;
    public void setAccountDao(AccountDaoImpl accountDao) {
        this.accountDao = accountDao;
    }

    /**
     * 查询所有信息
     */
    public List<Account> findAll() {
        return accountDao.findAll();
    }

    /**
     * 按 id 查询信息
     */
    public Account findById(int id) {
        return accountDao.findById(id);
    }

    /**
     * 按 username 查询信息
     */
    public Account findByName(String username) {
        return accountDao.findByName(username);
    }

    /**
     * 添加信息
     */
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    /**
     * 修改信息
     */
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    /**
     * 删除信息
     */
    public void deleteById(int id) {
        accountDao.deleteById(id);
    }

    /**
     * 交换信息，将 username1 和 username2 的名字交换
     */
    public void changeMessage(String username1, String username2) {
        accountDao.changeMessage(username1, username2);
    }
}

第四步：编写持久层接口和实现类

//持久层接口
public interface IAccountDao {
    //查询所有
    List<Account> findAll();

    //按 id 查询
    Account findById(int id);

    //按 username 查询
    Account findByName(String username);

    //添加信息
    void saveAccount(Account account);

    //修改信息
    void updateAccount(Account account);

    //按 id 删除信息
    void deleteById(int id);

    //交换信息
    void changeMessage(String username1, String username2);
}


//持久层实现类
public class AccountDaoImpl extends JdbcDaoSupport implements IAccountService {

    /**
     * 查询所有信息
     */
    public List<Account> findAll() {
        List<Account> accounts = super.getJdbcTemplate().query("select * from caogao", new BeanPropertyRowMapper<Account>(Account.class));
        return accounts;
    }

    /**
     * 按 id 查询信息
     */
    public Account findById(int id) {
        List<Account> accounts = super.getJdbcTemplate().query("select * from caogao where id=?", new BeanPropertyRowMapper<Account>(Account.class), 2);
        return accounts.isEmpty() ? null : accounts.get(0);
    }

    /**
     * 按 username 查询信息
     */
    public Account findByName(String username) {
        List<Account> accounts = super.getJdbcTemplate().query("select * from caogao where username=?", new BeanPropertyRowMapper<Account>(Account.class), username);
        return accounts.isEmpty() ? null : accounts.get(0);
    }

    /**
     * 添加信息
     */
    public void saveAccount(Account account) {
        super.getJdbcTemplate().update("insert into caogao(username, password) values(?,?)", account.getUsername(), account.getPassword());
    }

    /**
     * 修改信息
     */
    public void updateAccount(Account account) {
        super.getJdbcTemplate().update("update caogao set username=?, password=? where id=?", account.getUsername(), account.getPassword(), account.getId());
    }

    /**
     * 删除信息
     */
    public void deleteById(int id) {
        super.getJdbcTemplate().update("delete from caogao where id=?", id);
    }

    /**
     * 交换信息，将 username1 和 username2 的信息交换
     */
    public void changeMessage(String username1, String username2) {
        //1、查询 username1 的信息
        Account user1 = findByName(username1);
        //2、查询 username2 的信息
        Account user2 = findByName(username2);
        //3、修改 username1 的信息
        user1.setUsername(username2);
        //4、修改 username2 的信息
        user2.setUsername(username1);
        //5、更新 username1 的信息
        updateAccount(user1);
        //模拟网络错误
        int i = 10 / 0;
        //6、更新 username2 的信息
        updateAccount(user2);
    }
}

第五步：在配置文件中配置业务层和持久层对


<bean id="accountService" class="cn.itfzk.spring09.service.impl.AccountServiceImpl" >
    <property name="accountDao" ref="accountDao" >property>
bean>


<bean id="accountDao" class="cn.itfzk.spring09.dao.impl.AccountDaoImpl" >
    <property name="dataSource" ref="dataSource">property>
bean>


<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >
    <property name="driverClass" value="com.mysql.jdbc.Driver" >property>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/fzk" >property>
    <property name="user" value="root" >property>
    <property name="password" value="123456" >property>
bean>

第六步：配置事务管理器


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

第七步：配置事务的通知引用事务管理器 tx:advice


<tx:advice id="txAdvice" transaction-manager="transactionManager">
tx:advice>

第八步：配置事务的属性 tx:attributes、tx:method


<tx:advice id="txAdvice" transaction-manager="transactionManager">
    
    <tx:attributes>
        <tx:method name="*" propagation="REQUIRED" read-only="false"/>
        <tx:method name="find*" propagation="SUPPORTS" read-only="true">tx:method>
    tx:attributes>
tx:advice>

第九步：配置 AOP 切入点表达式 aop:config、aop:pointcut


<aop:config>
    <aop:pointcut id="pt" expression="execution(* cn.itfzk.spring09.service.impl.AccountServiceImpl.*(..))"/>
aop:config>

第十步：配置切入点表达式和事务通知的对应关系 aop:advisor


<aop:config>
    <aop:pointcut id="pt" expression="execution(* cn.itfzk.spring09.service.impl.AccountServiceImpl.*(..))"/>
    
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pt">aop:advisor>
aop:config>

作用：事务的属性
属性：
- name ：名称
- isolation ：事务的隔离级别
  - DEFAULT ：默认值，表示数据库的默认隔离级别
  - READ_COMMITTED ：读取提交的数据
  - READ_UNCOMMITTED ：解决脏读
  - REPEATABLE_READ ：解决不可重复读
  - SERIALIZABLE ：解决幻读
- propagation ：指定事务的传播行为
  - REQUIRED ：默认值，表示一定会有事务，增删改的选择
  - SUPPORTS ：查询可以的选择
  - MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常
  - REQUERS_NEW：新建事务，如果当前在事务中，把当前事务挂起。
  - NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
  - NEVER：以非事务方式运行，如果当前存在事务，抛出异常
  - NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行 REQUIRED 类似的操作。
- timeout ：事务的超时时间，默认值是 -1 ，表示永不超时，如果指定数值则以秒为单位
- read-only ：事务是否只读，只有查询方法才能设置为 true，默认值为 false 表示读写
- rollback-for ：用于指定一个异常，当产生该异常时，事务回滚，其他异常时，事务不回滚，没有默认值。表示如何异常都回滚
- no-rollback-for ：用于指定一个异常，当产生该异常时，事务不回滚，其他异常时，事务回滚，没有默认值。表示如何异常都回滚
```
<tx:attributes>
    <tx:method name="*" propagation="REQUIRED" read-only="false"/>
    <tx:method name="find*" propagation="SUPPORTS" read-only="true">tx:method>
    <tx:method name="" isolation="" propagation="" read-only="" timeout="" rollback-for="" no-rollback-for="">tx:method>
tx:attributes>
```

aop:advisor

作用：建立事务通知和切入点表达式的对应关系

<aop:config>
    <aop:pointcut id="pt" expression="execution(* cn.itfzk.spring09.service.impl.AccountServiceImpl.*(..))"/>
    
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pt">aop:advisor>
aop:config>

基于注解的配置方式

步骤（七步）

第一步：导入必备的 jar 包到工程中

<dependencies>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-testartifactId>
        <version>5.2.0.RELEASEversion>
        <scope>testscope>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-jdbcartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-txartifactId>
        <version>5.2.0.RELEASEversion>
    dependency>

    <dependency>
        <groupId>org.hamcrestgroupId>
        <artifactId>hamcrest-coreartifactId>
        <version>1.3version>
    dependency>
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
    dependency>

    <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
        <version>5.1.27version>
    dependency>
    <dependency>
        <groupId>commons-dbutilsgroupId>
        <artifactId>commons-dbutilsartifactId>
        <version>1.6version>
    dependency>
    <dependency>
        <groupId>c3p0groupId>
        <artifactId>c3p0artifactId>
        <version>0.9.1.2version>
    dependency>

    <dependency>
        <groupId>cglibgroupId>
        <artifactId>cglibartifactId>
        <version>2.1_3version>
    dependency>

    <dependency>
        <groupId>org.aspectjgroupId>
        <artifactId>aspectjweaverartifactId>
        <version>1.9.5version>
    dependency>
dependencies>

第二步：创建 spring 的配置文件并导入约束


<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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd">

beans>

第三步：创建业务层接口和实现类并使用注解让 spring 管理

@Service("accountService")  //使用注解让 spring 管理  
public class AccountServiceImpl implements IAccountService {
    @Autowired
    private IAccountDao accountDao;
    
    public void changeAccount(int id1, int id2){
        Account account1 = accountDao.findById(id1);
        Account account2 = accountDao.findById(id2);
        String name = account1.getUsername();
        account1.setUsername(account2.getUsername());
        account2.setUsername(name);
        accountDao.update(account1);
        int i = 10 / 0;
        accountDao.update(account2);
    }
}

第四步：创建持久层接口和实现类并使用注解让 spring 管理

@Repository("accountDao")  //使用注解让 spring 管理  
public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {
}

第五步：配置事务管理器并注入数据源

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

第六步：在业务层使用@Transactional 注解

@Service("accountService")
@Transactional(propagation = Propagation.SUPPORTS, readOnly = false)  //使用@Transactional 注解  
public class AccountServiceImpl implements IAccountService {
}

第七步：在配置文件中开启 spring 对注解事务的支持

<tx:annotation-driven transaction-manager="transactionManager">tx:annotation-driven>

不使用 xml 的配置方式

@Configuration
@EnableTransactionManagement  //TransactionManagement
public class SpringTxConfiguration {
}

注解

@Transactional

作用
- 事务的通知
属性
- 和 xml 中的属性含义一致。
- 该注解可以出现在接口上，类上和方法上。
  - 出现接口上，表示该接口的所有实现类都有事务支持。
  - 出现在类上，表示类中所有方法有事务支持
  - 出现在方法上，表示方法有事务支持。
  - 以上三个位置的优先级：方法 > 类 > 接口

你可能感兴趣的:(Spring,SSM框架,spring,java,mysql,sql)

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
mysql禁用远程登录 igotyback mysql
去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
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()，那么我们在接口
SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQL Server 数据库 sqlserver
1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
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：做与用户的交互行为文章目录前端学习路线
MYSQL面试系列-04 king01299 面试 mysql 面试
MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
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的运行
nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
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和其他两个虚拟机
关于Mysql 中 Row size too large (＞ 8126) 错误的解决和理解秋刀prince mysql mysql 数据库
提示：啰嗦一嘴，数据库的任何操作和验证前，一定要记得先备份！！！不会有错；文章目录问题发现一、问题导致的可能原因1、页大小2、行格式2.1compact格式2.2Redundant格式2.3Dynamic格式2.4Compressed格式3、BLOB和TEXT列二、解决办法1、修改页大小（不推荐）2、修改行格式3、修改数据类型为BLOB和TEXT列4、其他优化方式（可以参考使用）4.1合理设置数据
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支持分
MongoDB知识概括 GeorgeLin98 持久层 mongodb
MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
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做一
Java序列化进阶篇 g21121 java序列化
1.transient 类一旦实现了Serializable 接口即被声明为可序列化，然而某些情况下并不是所有的属性都需要序列化，想要人为的去阻止这些属性被序列化，就需要用到transient 关键字。
escape()、encodeURI()、encodeURIComponent()区别详解 aigo JavaScript Web
原文：http://blog.sina.com.cn/s/blog_4586764e0101khi0.html JavaScript中有三个可以对字符串编码的函数，分别是： escape,encodeURI,encodeURIComponent，相应3个解码函数：,decodeURI,decodeURIComponent 。下面简单介绍一下它们的区别 1 escape()函
ArcgisEngine实现对地图的放大、缩小和平移 Cb123456 添加矢量数据对地图的放大、缩小和平移 Engine
ArcgisEngine实现对地图的放大、缩小和平移: 个人觉得是平移，不过网上的都是漫游，通俗的说就是把一个地图对象从一边拉到另一边而已。就看人说话吧. 具体实现: 一、引入命名空间 using ESRI.ArcGIS.Geometry; using ESRI.ArcGIS.Controls; 二、代码实现.
Java集合框架概述天子之骄 Java集合框架概述
集合框架集合框架可以理解为一个容器，该容器主要指映射(map)、集合(set)、数组(array)和列表(list)等抽象数据结构。从本质上来说，Java集合框架的主要组成是用来操作对象的接口。不同接口描述不同的数据类型。简单介绍： Collection接口是最基本的接口，它定义了List和Set，List又定义了LinkLi
旗正4.0页面跳转传值问题何必如此 java jsp
跳转和成功提示 a) 成功字段非空forward 成功字段非空forward，不会弹出成功字段，为jsp转发，页面能超链接传值,传输变量时需要拼接。接拼接方式list.jsp?test="+strweightUnit+"或list.jsp?test="+weightUnit+&qu
全网唯一:移动互联网服务器端开发课程 cocos2d-x小菜 web开发移动开发移动端开发移动互联程序员
移动互联网时代来了！ App市场爆发式增长为Web开发程序员带来新一轮机遇，近两年新增创业者，几乎全部选择了移动互联网项目！传统互联网企业中超过98%的门户网站已经或者正在从单一的网站入口转向PC、手机、Pad、智能电视等多端全平台兼容体系。据统计，AppStore中超过85%的App项目都选择了PHP作为后端程
Log4J通用配置|注意问题笔记 7454103 DAO apache tomcat log4j Web
关于日志的等级那些去百度就知道了！这几天要搭个新框架配置了日志记下来！做个备忘！ #这里定义能显示到的最低级别,若定义到INFO级别,则看不到DEBUG级别的信息了~! log4j.rootLogger=INFO,allLog # DAO层 log记录到dao.log 控制台和总日志文件 log4j.logger.DAO=INFO,dao,C
SQLServer TCP/IP 连接失败问题 ---SQL Server Configuration Manager darkranger sql c windows SQL Server XP
当你安装完之后,连接数据库的时候可能会发现你的TCP/IP 没有启动.. 发现需要启动客户端协议 : TCP/IP 需要打开 SQL Server Configuration Manager... 却发现无法打开 SQL Server Configuration Manager..?? 解决方法: C:\WINDOWS\system32目录搜索framedyn.
[置顶] 做有中国特色的程序员 aijuans 程序员
从出版业说起网络作品排到靠前的，都不会太难看，一般人不爱看某部作品也是因为不喜欢这个类型，而此人也不会全不喜欢这些网络作品。究其原因，是因为网络作品都是让人先白看的，看的好了才出了头。而纸质作品就不一定了，排行榜靠前的，有好作品，也有垃圾。许多大牛都是写了博客，后来出了书。这些书也都不次，可能有人让为不好，是因为技术书不像小说，小说在读故事，技术书是在学知识或温习知识，有些技术书读得可
document.domain 跨域问题 avords document
document.domain用来得到当前网页的域名。比如在地址栏里输入：javascript:alert(document.domain); //www.315ta.com我们也可以给document.domain属性赋值，不过是有限制的，你只能赋成当前的域名或者基础域名。比如：javascript:alert(document.domain = "315ta.com");
关于管理软件的一些思考 houxinyou 管理
工作好多看年了,一直在做管理软件,不知道是我最开始做的时候产生了一些惯性的思维,还是现在接触的管理软件水平有所下降.换过好多年公司,越来越感觉现在的管理软件做的越来越乱. 在我看来,管理软件不论是以前的结构化编程,还是现在的面向对象编程,不管是CS模式,还是BS模式.模块的划分是很重要的.当然,模块的划分有很多种方式.我只是以我自己的划分方式来说一下. 做为管理软件,就像现在讲究MVC这
NoSQL数据库之Redis数据库管理(String类型和hash类型) bijian1013 redis 数据库 NoSQL
一.Redis的数据类型 1.String类型及操作 String是最简单的类型，一个key对应一个value，string类型是二进制安全的。Redis的string可以包含任何数据，比如jpg图片或者序列化的对象。 Set方法：设置key对应的值为string类型的value
Tomcat 一些技巧征客丶 java tomcat dos
以下操作都是在windows 环境下一、Tomcat 启动时配置 JAVA_HOME 在 tomcat 安装目录，bin 文件夹下的 catalina.bat 或 setclasspath.bat 中添加 set JAVA_HOME=JAVA 安装目录 set JRE_HOME=JAVA 安装目录/jre 即可；二、查看Tomcat 版本在 tomcat 安装目
【Spark七十二】Spark的日志配置 bit1129 spark
在测试Spark Streaming时，大量的日志显示到控制台，影响了Spark Streaming程序代码的输出结果的查看(代码中通过println将输出打印到控制台上)，可以通过修改Spark的日志配置的方式，不让Spark Streaming把它的日志显示在console 在Spark的conf目录下，把log4j.properties.template修改为log4j.p
Haskell版冒泡排序 bookjovi 冒泡排序 haskell
面试的时候问的比较多的算法题要么是binary search，要么是冒泡排序，真的不想用写C写冒泡排序了，贴上个Haskell版的，思维简单，代码简单，下次谁要是再要我用C写冒泡排序，直接上个haskell版的，让他自己去理解吧。 sort [] = [] sort [x] = [x] sort (x:x1:xs) | x>x1 = x1:so
java 路径配置文件读取 bro_feng java
这几天做一个项目，关于路径做如下笔记，有需要供参考。取工程内的文件，一般都要用相对路径，这个自然不用多说。在src统计目录建配置文件目录res,在res中放入配置文件。读取文件使用方式： 1. MyTest.class.getResourceAsStream("/res/xx.properties") 2. properties.load(MyTest.
读《研磨设计模式》-代码笔记-简单工厂模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * 个人理解：简单工厂模式就是IOC; * 客户端要用到某一对象，本来是由客户创建的，现在改成由工厂创建，客户直接取就好了 */ interface IProduct {
SVN与JIRA的关联 chenyu19891124 SVN
SVN与JIRA的关联一直都没能装成功，今天凝聚心思花了一天时间整合好了。下面是自己整理的步骤：一、搭建好SVN环境，尤其是要把SVN的服务注册成系统服务二、装好JIRA，自己用是jira-4.3.4破解版三、下载SVN与JIRA的插件并解压，然后拷贝插件包下lib包里的三个jar，放到Atlassian\JIRA 4.3.4\atlassian-jira\WEB-INF\lib下，再
JWFDv0.96 最新设计思路 comsci 数据结构算法工作企业应用公告
随着工作流技术的发展，工作流产品的应用范围也不断的在扩展，开始进入了像金融行业(我已经看到国有四大商业银行的工作流产品招标公告了)，实时生产控制和其它比较重要的工程领域，而
vi 保存复制内容格式粘贴 daizj vi 粘贴复制保存原格式不变形
vi是linux中非常好用的文本编辑工具，功能强大无比，但对于复制带有缩进格式的内容时，粘贴的时候内容错位很严重，不会按照复制时的格式排版，vi能不能在粘贴时，按复制进的格式进行粘贴呢？答案是肯定的，vi有一个很强大的命令可以实现此功能。在命令模式输入:set paste，则进入paste模式，这样再进行粘贴时
shell脚本运行时报错误：/bin/bash^M: bad interpreter 的解决办法 dongwei_6688 shell脚本
出现原因：windows上写的脚本，直接拷贝到linux系统上运行由于格式不兼容导致解决办法： 1. 比如文件名为myshell.sh，vim myshell.sh 2. 执行vim中的命令 : set ff?查看文件格式，如果显示fileformat=dos，证明文件格式有问题 3. 执行vim中的命令 :set fileformat=unix 将文件格式改过来就可以了，然后:w
高一上学期难记忆单词 dcj3sjt126com word english
honest 诚实的；正直的 argue 争论 classical 古典的 hammer 锤子 share 分享；共有 sorrow 悲哀；悲痛 adventure 冒险 error 错误；差错 closet 壁橱；储藏室 pronounce 发音；宣告 repeat 重做；重复 majority 大多数；大半 native 本国的，本地的，本国
hibernate查询返回DTO对象，DTO封装了多个pojo对象的属性 frankco POJO hibernate查询 DTO
DTO-数据传输对象；pojo-最纯粹的java对象与数据库中的表一一对应。简单讲：DTO起到业务数据的传递作用，pojo则与持久层数据库打交道。有时候我们需要查询返回DTO对象，因为DTO
Partition List hcx2013 partition
Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x. You should preserve the original relative order of th
Spring MVC测试框架详解——客户端测试 jinnianshilongnian
上一篇《Spring MVC测试框架详解——服务端测试》已经介绍了服务端测试，接下来再看看如果测试Rest客户端，对于客户端测试以前经常使用的方法是启动一个内嵌的jetty/tomcat容器，然后发送真实的请求到相应的控制器；这种方式的缺点就是速度慢；自Spring 3.2开始提供了对RestTemplate的模拟服务器测试方式，也就是说使用RestTemplate测试时无须启动服务器，而是模拟一
关于推荐个人观点 liyonghui160com 推荐系统关于推荐个人观点
回想起来，我也做推荐了3年多了，最近公司做了调整招聘了很多算法工程师，以为需要多么高大上的算法才能搭建起来的，从实践中走过来，我只想说【不是这样的】第一次接触推荐系统是在四年前入职的时候，那时候，机器学习和大数据都是没有的概念，什么大数据处理开源软件根本不存在，我们用多台计算机web程序记录用户行为，用.net的w
不间断旋转的动画 pangyulei 动画
CABasicAnimation* rotationAnimation; rotationAnimation = [CABasicAnimation animationWithKeyPath:@"transform.rotation.z"]; rotationAnimation.toValue = [NSNumber numberWithFloat: M
自定义annotation sha1064616837 java enum annotation reflect
对象有的属性在页面上可编辑，有的属性在页面只可读，以前都是我们在页面上写死的，时间一久有时候会混乱，此处通过自定义annotation在类属性中定义。越来越发现Java的Annotation真心很强大，可以帮我们省去很多代码，让代码看上去简洁。下面这个例子主要用到了 1.自定义annotation：@interface，以及几个配合着自定义注解使用的几个注解 2.简单的反射 3.枚举
Spring 源码 up2pu spring
1.Spring源代码 https://github.com/SpringSource/spring-framework/branches/3.2.x 注：兼容svn检出 2.运行脚本 import-into-eclipse.bat 注：需要设置JAVA_HOME为jdk 1.7 build.gradle compileJava { sourceCompatibilit
利用word分词来计算文本相似度 yangshangchuan word word分词文本相似度余弦相似度简单共有词
word分词提供了多种文本相似度计算方式：方式一：余弦相似度，通过计算两个向量的夹角余弦值来评估他们的相似度实现类：org.apdplat.word.analysis.CosineTextSimilarity 用法如下： String text1 = "我爱购物"; String text2 = "我爱读书"; String text3 =

Spring核心技术与简单使用

Spring

文章目录

1、Spring 概述

Spring 是什么

Spring 的优势

2、IOC（控制反转）

程序的耦合和解耦

耦合和解耦概念

工厂模式解耦

IOC 的概念和作用

IOC 控制反转

基于 XML 的配置实现 IOC

步骤（四步）

IOC 中 bean 标签和管理对象

bean 标签

bean 的作用范围和生命周期

实例化 Bean 的三种方式

Spring 的依赖注入

依赖注入的概念

构造函数注入

set 方法的注入:（更常用）

复杂类型的注入/集合类型的注入

使用 spring 的 IoC 的实现账户的CRUD (增删改查)

基于注解的配置 实现 IOC

步骤（四步）

常用注解

用于创建对象

用于改变作用范围

和生命周期相关

用于注入数据

Spring 注解和 XML 的选择问题

Spring 的纯注解配置

3、Spring 整合 Junit

步骤（四步）

4、AOP（面向切面编程）

AOP 概述

AOP 概念

AOP 的作用及优势

动态代理技术实现（CRUD）

Spring 中的 AOP

AOP 相关术语

基于 XML 的 AOP 配置

步骤（七步）

标签

aop:config

aop:aspect

aop:before、aop:after-returning、aop:after-throwing、aop:after

aop:around（环绕通知）

aop:pointcut

基于 注解 的 AOP 配置

步骤（八步）

注解

@Aspect

@Before 、 @AfterReturning 、 @AfterThrowing 、@After

@Around

@Pointcut

@EnableAspectJAutoProxy（纯注解的配置方式 ）

5、Spring 中的 JdbcTemplate

概述

JdbcTemplate 的增删改查操作

不在 dao 中使用 JdbcTemplate

在 dao 中使用 JdbcTemplate

方法一

方法二：让 dao 继承 JdbcDaoSupport

6、Spring 中的事务控制

Spring 中事务控制的 API 介绍

事务的隔离级别

事务的传播行为

超时时间

是否是只读事务

基于 XML 的声明式事务控制

步骤（十步）

标签

tx:advice

tx:attributes、tx:method

aop:advisor

基于 注解 的配置方式

步骤（七步）

不使用 xml 的配置方式

基于注解的配置实现 IOC

基于注解的 AOP 配置

@EnableAspectJAutoProxy（纯注解的配置方式）

基于注解的配置方式