SSM---------------------Spring

2024-04-27 18:38
文章标签 java ssm spring ---------------------

本文主要是介绍SSM---------------------Spring，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Spring

  • 1. spring概述
  • 2. IOC概念
    • 2.1 耦合
    • 2.2 工厂模式解耦
    • 2.3 单例模式优化工厂解耦
    • 2.4 IOC概念
  • 3.使用spring的IOC解决程序耦合
    • 3.1 spring基于xml的IOC环境搭建
    • 3.2 ApplicationContext的三个常用实现类
    • 3.3 创建bean（service或dao的实例）的三种方式
    • 3.4 spring中的依赖注入IOC
  • 4. spring整合Junit
  • 5. 事务问题
  • 6.代理
    • 6.1 基于接口的动态代理
    • 6.2 基于子类的动态代理
    • 6.3 动态代理实现事务控制
  • 7. AOP面向切面编程
  • 8. spring基于xml的AOP
    • 8.1 spring中使用切面表达式实现AOP
    • 8.2 四种通知类型
    • 8.3 spring基于注解的AOP
    • 8.4 spring基于xml的声明式事务控制
    • 8.5 spring基于注解的声明式事务控制
  • 9. jdbcTemplate使用

1. spring概述

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

2. IOC概念

2.1 耦合

package com.iteima.jdbc;import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;/*** 程序的耦合*      耦合：程序间的依赖关系*          包括：*              类之间的依赖*              方法间的依赖*      解耦：*          降低程序间的依赖关系*      实际开发中：*          应该做到：编译期不依赖，运行时才依赖。*      解耦的思路：*          第一步：使用反射来创建对象，而避免使用new关键字。*          第二步：通过读取配置文件来获取要创建的对象全限定类名**/
public class JdbcDemo1 {public static void main(String[] args) throws  Exception{//1.注册驱动
//        DriverManager.registerDriver(new com.mysql.jdbc.Driver());Class.forName("com.mysql.jdbc.Driver");//2.获取连接Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/eesy","root","1234");//3.获取操作数据库的预处理对象PreparedStatement pstm = conn.prepareStatement("select * from account");//4.执行SQL，得到结果集ResultSet rs = pstm.executeQuery();//5.遍历结果集while(rs.next()){System.out.println(rs.getString("name"));}//6.释放资源rs.close();pstm.close();conn.close();}
}

2.2 工厂模式解耦

在这里插入图片描述

其实就是不用new service层impl和dao层impl了，把service和dao层接口写到配置文件中，通过反射创建实例。

  • bean properties
AccountService=com.itheima.service.impl.AccountServiceImpl
AccountDao=com.itheima.dao.impl.AccountDaoIpml
  • 创建bean工厂
package com.itheima.factory;import java.io.InputStream;
import java.util.Properties;/*** 一个创建Bean对象的工厂** Bean：在计算机英语中，有可重用组件的含义。* JavaBean：用java语言编写的可重用组件。*      javabean >  实体类**   它就是创建我们的service和dao对象的。**   第一个：需要一个配置文件来配置我们的service和dao*           配置的内容：唯一标识=全限定类名（key=value)*   第二个：通过读取配置文件中配置的内容，反射创建对象**   我的配置文件可以是xml也可以是properties*/
public class BeanFactory {private static Properties props;//使用静态代码块为bean对象赋值static {try {props=new Properties();//别用fileinputstream，用类加载器，因为你properties文件路径可能需要修改，不能保证文件路径一直是这个。InputStream in =BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");props.load(in);} catch (Exception e) {throw new ExceptionInInitializerError("初始化properties失败");}}/*** 根据Bean的名称获取bean对象* @param beanName* @return*/public static Object getBean(String beanName) {Object bean = null;try {String beanPath = props.getProperty(beanName);//            System.out.println(beanPath);//用反射创建实例bean = Class.forName(beanPath).newInstance();//每次都会调用默认构造函数创建对象} catch (Exception e) {e.printStackTrace();}return bean;}
}
  • 模仿servlet调用service层
public class Client {public static void main(String[] args) {
//    AccountService as = new AccountServiceImpl();AccountService as = (AccountService) BeanFactory.getBean("AccountService");as.saveAccount();}
}

2.3 单例模式优化工厂解耦

因为每次都调用构造函数创建对象，所以是多例模式，明显单例模式效率更高，但是单例模式会带来线程安全问题。在我们这个例子中没有线程安全问题（没有多个成员方法访问同一类成员变量），所以可以调整为单例模式。
应该创建一个容器存储实例，否则实例会被垃圾回收机制回收。

对factory修改

public class BeanFactory {private static Properties props;//定义一个Map,用于存放我们要创建的对象。我们把它称之为容器private static Map<String,Object> beans;//使用静态代码块为bean对象赋值static {try {props=new Properties();//别用fileinputstream，用类加载器，因为你properties文件路径可能需要修改，不能保证文件路径一直是这个。InputStream in =BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");props.load(in);//实例化容器beans = new HashMap<String,Object>();//取出配置文件中所有的KeyEnumeration keys = props.keys();//遍历枚举while (keys.hasMoreElements()){//取出每个KeyString key = keys.nextElement().toString();//根据key获取valueString beanPath = props.getProperty(key);//反射创建对象Object value = Class.forName(beanPath).newInstance();//把key和value存入容器中beans.put(key,value);}} catch (Exception e) {throw new ExceptionInInitializerError("初始化properties失败");}}/*** 根据Bean的名称获取bean对象* @param beanName* @return*/public static Object getBean(String beanName) {//从容器中取出bean对象return beans.get(beanName);}
}

2.4 IOC概念

IOC,控制反转，把创建对象的权利交给框架，是框架的重要特征，并非面向对象编程的专用术语。它包括依赖注入和依赖查找。

3.使用spring的IOC解决程序耦合

3.1 spring基于xml的IOC环境搭建

和上面没差，把properties配置文件删掉，采用xml文件
在这里插入图片描述

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd"><!--把对象的创建交给spring来管理--><bean id="AccountService" class="com.itheima.service.impl.AccountServiceImpl"></bean><bean id="AccountDao" class="com.itheima.dao.impl.AccountDaoImpl"></bean>
</beans>

3.2 ApplicationContext的三个常用实现类

ApplicationContext：是spring继BeanFactory之外的另一个核心接口或容器，允许容器通过应用程序上下文环境创建、获取、管理bean。

  • ClassPathXmlApplicationContext：它可以加载类路径下的配置文件，要求配置文件必须在类路径下。不在的话，加载不了。(更常用)

  • FileSystemXmlApplicationContext：它可以加载磁盘任意路径下的配置文件(必须有访问权限）

  • AnnotationConfigApplicationContext：它是用于读取注解创建容器的。

/**- 获取spring的Ioc核心容器，并根据id获取对象-  - ApplicationContext的三个常用实现类：-      ClassPathXmlApplicationContext：它可以加载类路径下的配置文件，要求配置文件必须在类路径下。不在的话，加载不了。(更常用)-      FileSystemXmlApplicationContext：它可以加载磁盘任意路径下的配置文件(必须有访问权限）-  -      AnnotationConfigApplicationContext：它是用于读取注解创建容器的，是明天的内容。-  - 核心容器的两个接口引发出的问题：-  ApplicationContext:     单例对象适用              采用此接口-      它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象。-  -  BeanFactory:            多例对象使用-      它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式。也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象。- @param */
public class Client {public static void main(String[] args) {//1.获取核心容器对象ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//        ApplicationContext ac = new FileSystemXmlApplicationContext("C:\\Users\\zhy\\Desktop\\bean.xml");//2.根据id获取Bean对象AccountService as  = (AccountService)ac.getBean("AccountService");AccountDao adao = ac.getBean("AccountDao", AccountDao.class);System.out.println(as);System.out.println(adao);//        --------BeanFactory----------
//        Resource resource = new ClassPathResource("bean.xml");
//        BeanFactory factory = new XmlBeanFactory(resource);
//        AccountService as  = (AccountService)factory.getBean("AccountService");
//        System.out.println(as);}
}

3.3 创建bean（service或dao的实例）的三种方式

创建Bean的三种方式

  1. 使用默认构造函数创建。
    在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。
    采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。也就是上面那种，如果在serviceimpl中加一个有参构造函数会报错，因为默认的无参构造函数没有了。bean中class是要实例化的类。
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>
  1. 使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）
    在这里插入图片描述
    建立一个工厂类，提供创建对象的方法getAccountService
<bean id="instanceFactory" class="com.itheima.factory.InstanceFactory"></bean>
<bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>
  1. 使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器)
    class是要实例化的类。factory-method是要调用的方法。id是bean的名字。
/*** 模拟一个工厂类（该类可能是存在于jar包中的，我们无法通过修改源码的方式来提供默认构造函数）*/
public class StaticFactory {public static AccountService getAccountService(){return new AccountServiceImpl();}
}

<bean id="AccountService" class="com.itheima.factory.StaticFactory" factory-method="getAccountService"></bean>

bean的作用范围调整

bean标签的scope属性：

  • 作用：用于指定bean的作用范围

  • 取值： 常用的就是单例的和多例的
    singleton：单例的（默认值）
    prototype：多例的
    request：作用于web应用的请求范围
    session：作用于web应用的会话范围
    global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session

bean对象的生命周期

  • 单例对象
    出生：当容器创建时对象出生
    活着：只要容器还在，对象一直活着
    死亡：容器销毁，对象消亡
    总结：单例对象的生命周期和容器相同

  • 多例对象
    出生：当我们使用对象时spring框架为我们创建
    活着：对象只要是在使用过程中就一直活着。
    死亡：当对象长时间不用，且没有别的对象引用时，由Java的垃圾回收器回收。

    3.4 spring中的依赖注入IOC

依赖注入：
Dependency Injection
IOC的作用：降低程序间的耦合（依赖关系）
依赖关系的管理： 以后都交给spring来维护
在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明。依赖关系的维护：就称之为依赖注入。
依赖注入：能注入的数据：有三类基本类型和String其他bean类型（在配置文件中或者注解配置过的bean）复杂类型/集合类型
注入的方式：

  • 第一种：使用构造函数提供
  • 第二种：使用set方法提供
  • 第三种：使用注解提供

1. 构造函数注入：
使用的标签:constructor-arg
标签出现的位置：bean标签的内部
标签中的属性

  • type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
  • index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始
  • name：用于指定给构造函数中指定名称的参数赋值 常用的

以上三个用于指定给构造函数中哪个参数赋值

  • value：用于提供基本类型和String类型的数据

  • ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象

    优势：
    在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。
    弊端：
    改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。

<bean id="AccountService" class="com.itheima.service.impl.AccountServiceImpl"><constructor-arg name="name" value="泰斯特"></constructor-arg><constructor-arg name="age" value="18"></constructor-arg><constructor-arg name="birthday" ref="now"></constructor-arg>
</bean>
<bean id="now" class="java.util.Date"></bean>

//实例化的类必须有构造函数
public AccountServiceImpl(String name, Integer age, Date birthday) {this.name = name;this.age = age;this.birthday = birthday;}

2. set注入：

set方法注入 更常用的方式
涉及的标签：property
出现的位置：bean标签的内部
标签的属性

  • name：用于指定注入时所调用的set方法名称（和属性名字没关系，和set方法名字有关系）

  • value：用于提供基本类型和String类型的数据

  • ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象

优势：
创建对象时没有明确的限制，可以直接使用默认构造函数
弊端：
如果有某个成员必须有值，则获取对象是有可能set方法没有执行。

<bean id="AccountService" class="com.itheima.service.impl.AccountServiceImpl"><property name="name" value="TEST" ></property><property name="age" value="21"></property><property name="birthday" ref="now"></property>
</bean>
<bean id="now" class="java.util.Date"></bean>

复杂类型集合的注入

复杂类型的注入/集合类型的注入
用于给List结构集合注入的标签： list array set
用于个Map结构集合注入的标签: map props
结构相同，标签可以互换

  private String[] myStrs;private List<String> mylist;private Set<String> myset;private Map<String,String> mymap;private Properties mypor;

<bean id="AccountService" class="com.itheima.service.impl.AccountServiceImpl"><property name="myStrs"><set><value>AAA</value><value>BBB</value><value>CCC</value></set></property><property name="mylist"><array><value>AAA</value><value>BBB</value><value>CCC</value></array></property><property name="myset"><list><value>AAA</value><value>BBB</value><value>CCC</value></list></property><property name="mymap"><props><prop key="testC">ccc</prop><prop key="testD">ddd</prop></props></property><property name="mypor"><map><entry key="testA" value="aaa"></entry><entry key="testB"><value>BBB</value></entry></map></property>
</bean>

3. 使用注解注入

 * 曾经XML的配置：*  <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"*        scope=""  init-method="" destroy-method="">*      <property name=""  value="" | ref=""></property>*  </bean>*  * 用于创建对象的*      他们的作用就和在XML配置文件中编写一个<bean>标签实现的功能是一样的*      @Component:*          作用：用于把当前类对象存入spring容器中*          属性：*              value：用于指定bean的id。当我们不写时，它的默认值是当前类名，且首字母改小写。*      @Controller：一般用在表现层*      @Service：一般用在业务层*      @Repository：一般用在持久层*      以上三个注解他们的作用和属性与Component是一模一样。*      他们三个是spring框架为我们提供明确的三层使用的注解，使我们的三层对象更加清晰*  *  * 用于注入数据的*      他们的作用就和在xml配置文件中的bean标签中写一个<property>标签的作用是一样的*      @Autowired:*          作用：自动按照类型注入。只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以注入成功*                如果ioc容器中没有任何bean的类型和要注入的变量类型匹配，则报错。*                如果Ioc容器中有多个类型匹配时：*          出现位置：*              可以是变量上，也可以是方法上*          细节：*              在使用注解注入时，set方法就不是必须的了。*      @Qualifier:*          作用：在按照类中注入的基础之上再按照名称注入。它在给类成员注入时不能单独使用，必须和@Autowired配合使用。但是在给方法参数注入时可以*          属性：*              value：用于指定注入bean的id。*      @Resource*          作用：直接按照bean的id注入。它可以独立使用*          属性：*              name：用于指定bean的id。*      以上三个注入都只能注入其他bean类型的数据，而基本类型和String类型无法使用上述注解实现。*      另外，集合类型的注入只能通过XML来实现。*  *      @Value*          作用：用于注入基本类型和String类型的数据*          属性：*              value：用于指定数据的值。它可以使用spring中SpEL(也就是spring的el表达式）*                      SpEL的写法：${表达式}*  * 用于改变作用范围的*      他们的作用就和在bean标签中使用scope属性实现的功能是一样的*      @Scope*          作用：用于指定bean的作用范围*          属性：*              value：指定范围的取值。常用取值：singleton 单例 prototype 多例 不写默认单例*  * 和生命周期相关 了解*      他们的作用就和在bean标签中使用init-method和destroy-methode的作用是一样的*      @PreDestroy*          作用：用于指定销毁方法*      @PostConstruct*          作用：用于指定初始化方法*/
  • 如果有两个AccountDaoImpl分别以accountdao1和accountdao2的id注入容器。那么会报错
    *NoUniqueBeanDefinitionException: No qualifying bean of type ‘com.itheima.dao.AccountDao’ available: expected single matching bean but found 2: accountDao1,accountDao2
    因为@Autowired发现了两个都实现AccountDao的AccountDaoImpl在这里插入图片描述
    加上@Qualifier用value指定要注入的AccountDaoImpl的id可以解决。但是@Qualifier它在给类成员注入时不能单独使用，必须和@Autowired配合使用。但是在给方法参数注入时可以。可以用 @Resource替换这两个。
    在这里插入图片描述
    @Scope作用范围
@Service(value = "AccountService")
@Scope(value = "prototype")
public class AccountServiceImpl implements AccountService {@Resource(name = "accountDao1")private AccountDao accountDao;public void saveAccount() {accountDao.saveAccount();}
}

4. 基于xml的IOC注入案例

在这里插入图片描述

package com.aiheima.dao.impl;import com.aiheima.dao.IAccountDao;
import com.aiheima.domain.Account;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;import java.util.List;/*** 账户的持久层实现类*/
public class AccountDaoImpl implements IAccountDao {private QueryRunner runner;public void setRunner(QueryRunner runner) {this.runner = runner;}public List<Account> findAllAccount() {try{return runner.query("select * from account",new BeanListHandler<Account>(Account.class));}catch (Exception e) {throw new RuntimeException(e);}}public Account findAccountById(Integer accountId) {try{return runner.query("select * from account where id = ? ",new BeanHandler<Account>(Account.class),accountId);}catch (Exception e) {throw new RuntimeException(e);}}public void saveAccount(Account account) {try{runner.update("insert into account(name,money)values(?,?)",account.getName(),account.getMoney());}catch (Exception e) {throw new RuntimeException(e);}}public void updateAccount(Account account) {try{runner.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());}catch (Exception e) {throw new RuntimeException(e);}}public void deleteAccount(Integer accountId) {try{runner.update("delete from account where id=?",accountId);}catch (Exception e) {throw new RuntimeException(e);}}
}

dbutils需要定义runner，详见JDBC专栏下的dbutils工具类使用。

package com.aiheima.service.impl;import com.aiheima.dao.IAccountDao;
import com.aiheima.domain.Account;
import com.aiheima.service.IAccountService;import java.util.List;/*** Created with IntelliJ IDEA.** @Auther: 何* @Date: 2021/03/18/14:14* @Description:*/
public class AccountServiceImpl implements IAccountService {private IAccountDao accountDao;public void setAccountDao(IAccountDao accountDao) {this.accountDao = accountDao;}public List<Account> findAllAccount() {return accountDao.findAllAccount();}public Account findAccountById(Integer id) {return accountDao.findAccountById(id);}public void saveAccount(Account account) {accountDao.saveAccount(account);}public void updateAccount(Account account) {accountDao.updateAccount(account);}public void deleteAccount(Integer accountId) {accountDao.deleteAccount(accountId);}
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 配置Service --><bean id="accountService" class="com.aiheima.service.impl.AccountServiceImpl"><!-- 注入dao --><property name="accountDao" ref="accountDao"></property></bean><!--配置Dao对象--><bean id="accountDao" class="com.aiheima.dao.impl.AccountDaoImpl"><!-- 注入QueryRunner --><property name="runner" ref="runner"></property></bean><!--配置QueryRunner--><bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype"><!--注入数据源--><constructor-arg name="ds" ref="dataSource"></constructor-arg></bean><!-- 配置数据源 --><bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"><!--连接数据库的必备信息--><property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property><property name="jdbcUrl" value="jdbc:mysql://localhost:3306/myspring?serverTimezone=UTC&amp;useUnicode=true&amp;characterEncoding=utf8"></property><property name="user" value="root"></property><property name="password" value="root"></property></bean>
</beans>

因为要通过Accountserviceimpl使用accountdao.findAllAccount,所以需要Accountserviceimpl对象，而它又需要注入accountdao对象，而accountdao对象又需要注入QueryRunner对象，而QueryRunner对象需要注入数据源。

public class AccountServiceTest {IAccountService as;@Beforepublic void init(){//获取容器ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");//得到对象as = (IAccountService) ac.getBean("accountService");}@Testpublic void testFindAll() {List<Account> accounts = as.findAllAccount();for(Account account : accounts){System.out.println(account);}}}

5. 基于注解的IOC案例

只需要在AccountDaoImpl和AccountServicelmpl前加上
在这里插入图片描述
然后把xml文件写成配置类

/*** 该类是一个配置类，它的作用和bean.xml是一样的* spring中的新注解* Configuration*     作用：指定当前类是一个配置类*     细节：当配置类作为AnnotationConfigApplicationContext对象创建的参数时，该注解可以不写。* ComponentScan*      作用：用于通过注解指定spring在创建容器时要扫描的包*      属性：*          value：它和basePackages的作用是一样的，都是用于指定创建容器时要扫描的包。*                 我们使用此注解就等同于在xml中配置了:*                      <context:component-scan base-package="com.itheima"></context:component-scan>*  Bean*      作用：用于把当前方法的返回值作为bean对象存入spring的ioc容器中*      属性:*          name:用于指定bean的id。当不写时，默认值是当前方法的名称*      细节：*          当我们使用注解配置方法时，如果方法有参数，spring框架会去容器中查找有没有可用的bean对象。*          查找的方式和Autowired注解的作用是一样的*  Import*      作用：用于导入其他的配置类*      属性：*          value：用于指定其他配置类的字节码。*                  当我们使用Import的注解之后，有Import注解的类就父配置类，而导入的都是子配置类*  PropertySource*      作用：用于指定properties文件的位置*      属性：*          value：指定文件的名称和路径。*                  关键字：classpath，表示类路径下*/@Configuration
@ComponentScan("com.aiheima")
@Import(JdbcConfig.class)
@PropertySource("JdbcConfig.properties")
public class SpringConfiguration {}
package com.aiheima.config;import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;import javax.sql.DataSource;/*** 和spring连接数据库相关的配置类*/
public class JdbcConfig {@Value("${jdbc.driver}")private String driver;@Value("${jdbc.url}")private String url;@Value("${jdbc.username}")private String username;@Value("${jdbc.password}")private String password;/*** 用于创建一个QueryRunner对象* @param dataSource* @return*/@Bean(name="runner")@Scope("prototype")public QueryRunner createQueryRunner(@Qualifier("ds2") DataSource dataSource){return new QueryRunner(dataSource);}/*** 创建数据源对象* @return*/@Bean(name="ds2")public DataSource createDataSource(){try {ComboPooledDataSource ds = new ComboPooledDataSource();ds.setDriverClass(driver);ds.setJdbcUrl(url);ds.setUser(username);ds.setPassword(password);return ds;}catch (Exception e){throw new RuntimeException(e);}}@Bean(name="ds1")public DataSource createDataSource1(){try {ComboPooledDataSource ds = new ComboPooledDataSource();ds.setDriverClass(driver);ds.setJdbcUrl(url);ds.setUser(username);ds.setPassword(password);return ds;}catch (Exception e){throw new RuntimeException(e);}}
}

在这里插入图片描述
这是全注解模式，也可半注解半xml

4. spring整合Junit

<dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>5.2.0.RELEASE</version>
</dependency>

/*** 使用Junit单元测试：测试我们的配置* Spring整合junit的配置*      1、导入spring整合junit的jar(坐标)*      2、使用Junit提供的一个注解把原有的main方法替换了，替换成spring提供的*             @Runwith*      3、告知spring的运行器，spring和ioc创建是基于xml还是注解的，并且说明位置*          @ContextConfiguration*                  locations：指定xml文件的位置，加上classpath关键字，表示在类路径下*                  classes：指定注解类所在地位置**   当我们使用spring 5.x版本的时候，要求junit的jar必须是4.12及以上*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class AccountServiceTest {@AutowiredIAccountService as=null;@Testpublic void testFindAll() {List<Account> accounts = as.findAllAccount();for(Account account : accounts){System.out.println(account);}}@Testpublic void testFindOne() {//3.执行方法Account account = as.findAccountById(1);System.out.println(account);}@Testpublic void testSave() {Account account = new Account();account.setName("test");account.setMoney(12345f);//3.执行方法as.saveAccount(account);}@Testpublic void testUpdate() {//3.执行方法Account account = as.findAccountById(4);account.setMoney(23456f);as.updateAccount(account);}@Testpublic void testDelete() {//3.执行方法as.deleteAccount(4);}
}

5. 事务问题

事务控制应该在业务层

 public void transfer(String sourceName, String targetName, Float money) {System.out.println("transfer....");//2.1根据名称查询转出账户Account source = accountDao.findAccountByName(sourceName);//2.2根据名称查询转入账户Account target = accountDao.findAccountByName(targetName);//2.3转出账户减钱source.setMoney(source.getMoney()-money);//2.4转入账户加钱target.setMoney(target.getMoney()+money);//2.5更新转出账户accountDao.updateAccount(source);//            int i=1/0;//2.6更新转入账户accountDao.updateAccount(target);}

出现事务问题的原因是业务层的transfer方法每步都重新获取了一个数据库连接，成功以后自动提交。我们要把这完整的操作使用同一个connection，使用threadlocal对象把connection和当前线程绑定，从而一个线程中只有一个能控制事务的对象。

package com.itheima.utils;import javax.sql.DataSource;
import java.sql.Connection;/*** 连接的工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定*/
public class ConnectionUtils {private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();private DataSource dataSource;public void setDataSource(DataSource dataSource) {this.dataSource = dataSource;}/*** 获取当前线程上的连接* @return*/public Connection getThreadConnection() {try{//1.先从ThreadLocal上获取Connection conn = tl.get();//2.判断当前线程上是否有连接if (conn == null) {//3.从数据源中获取一个连接，并且存入ThreadLocal中conn = dataSource.getConnection();tl.set(conn);}//4.返回当前线程上的连接return conn;}catch (Exception e){throw new RuntimeException(e);}}/*** 把连接和线程解绑*/public void removeConnection(){tl.remove();}
}
package com.itheima.utils;/*** 和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放连接*/
public class TransactionManager {private ConnectionUtils connectionUtils;public void setConnectionUtils(ConnectionUtils connectionUtils) {this.connectionUtils = connectionUtils;}/*** 开启事务*/public  void beginTransaction(){try {connectionUtils.getThreadConnection().setAutoCommit(false);}catch (Exception e){e.printStackTrace();}}/*** 提交事务*/public  void commit(){try {connectionUtils.getThreadConnection().commit();}catch (Exception e){e.printStackTrace();}}/*** 回滚事务*/public  void rollback(){try {connectionUtils.getThreadConnection().rollback();}catch (Exception e){e.printStackTrace();}}/*** 释放连接*/public  void release(){try {connectionUtils.getThreadConnection().close();//还回连接池中connectionUtils.removeConnection();}catch (Exception e){e.printStackTrace();}}
}

改造serviceimpl

package com.itheima.service.impl;import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import com.itheima.service.IAccountService;
import com.itheima.utils.TransactionManager;import java.util.List;/*** 账户的业务层实现类** 事务控制应该都是在业务层*/
public class AccountServiceImpl implements IAccountService {private IAccountDao accountDao;private TransactionManager txManager;public void setTxManager(TransactionManager txManager) {this.txManager = txManager;}public void setAccountDao(IAccountDao accountDao) {this.accountDao = accountDao;}public List<Account> findAllAccount() {try {//1.开启事务txManager.beginTransaction();//2.执行操作List<Account> accounts = accountDao.findAllAccount();//3.提交事务txManager.commit();//4.返回结果return accounts;}catch (Exception e){//5.回滚操作txManager.rollback();throw new RuntimeException(e);}finally {//6.释放连接txManager.release();}}public Account findAccountById(Integer accountId) {try {//1.开启事务txManager.beginTransaction();//2.执行操作Account account = accountDao.findAccountById(accountId);//3.提交事务txManager.commit();//4.返回结果return account;}catch (Exception e){//5.回滚操作txManager.rollback();throw new RuntimeException(e);}finally {//6.释放连接txManager.release();}}public void saveAccount(Account account) {try {//1.开启事务txManager.beginTransaction();//2.执行操作accountDao.saveAccount(account);//3.提交事务txManager.commit();}catch (Exception e){//4.回滚操作txManager.rollback();}finally {//5.释放连接txManager.release();}}public void updateAccount(Account account) {try {//1.开启事务txManager.beginTransaction();//2.执行操作accountDao.updateAccount(account);//3.提交事务txManager.commit();}catch (Exception e){//4.回滚操作txManager.rollback();}finally {//5.释放连接txManager.release();}}public void deleteAccount(Integer acccountId) {try {//1.开启事务txManager.beginTransaction();//2.执行操作accountDao.deleteAccount(acccountId);//3.提交事务txManager.commit();}catch (Exception e){//4.回滚操作txManager.rollback();}finally {//5.释放连接txManager.release();}}public void transfer(String sourceName, String targetName, Float money) {try {//1.开启事务txManager.beginTransaction();//2.执行操作//2.1根据名称查询转出账户Account source = accountDao.findAccountByName(sourceName);//2.2根据名称查询转入账户Account target = accountDao.findAccountByName(targetName);//2.3转出账户减钱source.setMoney(source.getMoney()-money);//2.4转入账户加钱target.setMoney(target.getMoney()+money);//2.5更新转出账户accountDao.updateAccount(source);int i=1/0;//2.6更新转入账户accountDao.updateAccount(target);//3.提交事务txManager.commit();}catch (Exception e){//4.回滚操作txManager.rollback();e.printStackTrace();}finally {//5.释放连接txManager.release();}}
}

PlatformTransactionManager :事务管理器(用来管理事务，包含事务的提交，回滚)
修改Accountdaoimpl
在这里插入图片描述
完善bean.xml配置
这样业务层每调用txManager就会得到该线程上的数据库连接。并且每次调用都是同一个连接
在这里插入图片描述

6.代理

  • 基于接口的动态代理

提供者：JDK 官方的 Proxy 类。
要求：被代理类最少实现一个接口。

  • 基于子类的动态代理

提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。
要求：被代理类不能用 final 修饰的类（最终类）。

6.1 基于接口的动态代理

/*** 一个生产者*/
public class Producer implements IProducer{/*** 销售* @param money*/public void saleProduct(float money){System.out.println("销售产品，并拿到钱："+money);}/*** 售后* @param money*/public void afterService(float money){System.out.println("提供售后服务，并拿到钱："+money);}
}

/*** 对生产厂家要求的接口*/
public interface IProducer {/*** 销售* @param money*/public void saleProduct(float money);/*** 售后* @param money*/public void afterService(float money);
}

package com.itheima.proxy;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** 模拟一个消费者*/
public class Client {public static void main(String[] args) {final Producer producer = new Producer();/*** 动态代理：*  特点：字节码随用随创建，随用随加载*  作用：不修改源码的基础上对方法增强*  分类：*      基于接口的动态代理*      基于子类的动态代理*  基于接口的动态代理：*      涉及的类：Proxy*      提供者：JDK官方*  如何创建代理对象：*      使用Proxy类中的newProxyInstance方法*  创建代理对象的要求：*      被代理类最少实现一个接口，如果没有则不能使用*  newProxyInstance方法的参数：*      ClassLoader：类加载器*          它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法。*      Class[]：字节码数组*          它是用于让代理对象和被代理对象有相同方法。固定写法。*      InvocationHandler：用于提供增强的代码*          它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。*          此接口的实现类都是谁用谁写。*/IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),producer.getClass().getInterfaces(),new InvocationHandler() {/*** 作用：执行被代理对象的任何接口方法都会经过该方法* 方法参数的含义* @param proxy   代理对象的引用* @param method  当前执行的方法* @param args    当前执行方法所需的参数* @return        和被代理对象方法有相同的返回值* @throws Throwable*/public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//提供增强的代码Object returnValue = null;//1.获取方法执行的参数Float money = (Float)args[0];//2.判断当前方法是不是销售if("saleProduct".equals(method.getName())) {returnValue = method.invoke(producer, money*0.8f);}return returnValue;}});proxyProducer.saleProduct(10000f);}
}

注意，匿名内部类调用外部变量要声明成final
在这里就实现了代理商挣2000，生产商挣8000

6.2 基于子类的动态代理

package com.itheima.cglib;import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;import java.lang.reflect.Method;/*** 模拟一个消费者*/
public class Client {public static void main(String[] args) {final Producer producer = new Producer();/*** 动态代理：*  特点：字节码随用随创建，随用随加载*  作用：不修改源码的基础上对方法增强*  分类：*      基于接口的动态代理*      基于子类的动态代理*  基于子类的动态代理：*      涉及的类：Enhancer*      提供者：第三方cglib库*  如何创建代理对象：*      使用Enhancer类中的create方法*  创建代理对象的要求：*      被代理类不能是最终类*  create方法的参数：*      Class：字节码*          它是用于指定被代理对象的字节码。**      Callback：用于提供增强的代码*          它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。*          此接口的实现类都是谁用谁写。*          我们一般写的都是该接口的子接口实现类：MethodInterceptor*/Producer cglibProducer = (Producer)Enhancer.create(producer.getClass(), new MethodInterceptor() {/*** 执行北地阿里对象的任何方法都会经过该方法* @param proxy* @param method* @param args*    以上三个参数和基于接口的动态代理中invoke方法的参数是一样的* @param methodProxy ：当前执行方法的代理对象* @return* @throws Throwable*/public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {//提供增强的代码Object returnValue = null;//1.获取方法执行的参数Float money = (Float)args[0];//2.判断当前方法是不是销售if("saleProduct".equals(method.getName())) {returnValue = method.invoke(producer, money*0.8f);}return returnValue;}});cglibProducer.saleProduct(12000f);}
}

在这里插入图片描述

6.3 动态代理实现事务控制

创建动态代理工厂

package com.itheima.factory;import com.itheima.service.IAccountService;
import com.itheima.utils.TransactionManager;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** 用于创建Service的代理对象的工厂*/
public class BeanFactory {private IAccountService accountService;private TransactionManager txManager;public void setTxManager(TransactionManager txManager) {this.txManager = txManager;}public final void setAccountService(IAccountService accountService) {this.accountService = accountService;}/*** 获取Service代理对象* @return*/public IAccountService getAccountService() {return (IAccountService)Proxy.newProxyInstance(accountService.getClass().getClassLoader(),accountService.getClass().getInterfaces(),new InvocationHandler() {/*** 添加事务的支持** @param proxy* @param method* @param args* @return* @throws Throwable*/public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Object rtValue = null;try {//1.开启事务txManager.beginTransaction();//2.执行操作rtValue = method.invoke(accountService, args);//3.提交事务txManager.commit();//4.返回结果return rtValue;} catch (Exception e) {//5.回滚操作txManager.rollback();throw new RuntimeException(e);} finally {//6.释放连接txManager.release();}}});}
}

在这里插入图片描述
setAccountService加上了final

简化业务层
在这里插入图片描述

<!--配置代理的service-->
<bean id="proxyAccountService" factory-bean="beanFactory" factory-method="getAccountService"></bean><!--配置beanfactory-->
<bean id="beanFactory" class="com.itheima.factory.BeanFactory"><!-- 注入service --><property name="accountService" ref="accountService"></property><!-- 注入事务管理器 --><property name="txManager" ref="txManager"></property>
</bean>

注意：现在有两个对象都实现IAccountService接口
Could not autowire. There is more than one bean of ‘IAccountService’ type.
Beans:
accountService (bean.xml)
proxyAccountService (bean.xml)
所以测试类注入加上@qualifier注解指定在这里插入图片描述

7. AOP面向切面编程

简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的
基础上，对我们的已有方法进行增强。

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

名词：

  1. Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的
    连接点。

  2. Pointcut(切入点):所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。

  3. Advice(通知/增强): 所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
    通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。

  4. Introduction(引介): 引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方 法或 Field。

  5. Target(目标对象): 代理的目标对象。

  6. Weaving(织入): 是指把增强应用到目标对象来创建新的代理对象的过程。 spring 采用动态代理织入，而 AspectJ采用编译期织入和类装载期织入。

  7. Proxy（代理）: 一个类被 AOP 织入增强后，就产生一个结果代理类。

  8. Aspect(切面): 是切入点和通知（引介）的结合。

8. spring基于xml的AOP

8.1 spring中使用切面表达式实现AOP

在这里插入图片描述
想要在执行serviceimpl之前做logger类中的printLog方法。

spring中基于XML的AOP配置步骤
1、把通知Bean也交给spring来管理
2、使用aop:config标签表明开始AOP的配置
3、使用aop:aspect标签表明配置切面
id属性：是给切面提供一个唯一标识
ref属性：是指定通知类bean的Id。
4、在aop:aspect标签的内部使用对应标签来配置通知的类型
我们现在示例是让printLog方法在切入点方法执行之前之前：所以是前置通知
aop:before：表示配置前置通知
method属性：用于指定Logger类中哪个方法是前置通知
pointcut属性：用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强

切入点表达式的写法：
关键字：execution(表达式)
表达式：
访问修饰符 返回值 包名.包名.包名…类名.方法名(参数列表)
标准的表达式写法：

 public void com.itheima.service.impl.AccountServiceImpl.saveAccount()

访问修饰符可以省略

 void com.itheima.service.impl.AccountServiceImpl.saveAccount()

  返回值可以使用通配符，表示任意返回值* com.itheima.service.impl.AccountServiceImpl.saveAccount()包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.* *.*.*.*.AccountServiceImpl.saveAccount())包名可以使用..表示当前包及其子包* *..AccountServiceImpl.saveAccount()类名和方法名都可以使用*来实现通配* *..*.*()参数列表：可以直接写数据类型：基本类型直接写名称           int引用类型写包名.类名的方式   java.lang.String可以使用通配符表示任意类型，但是必须有参数可以使用..表示有无参数均可，有参数可以是任意类型全通配写法：* *..*.*(..)实际开发中切入点表达式的通常写法：切到业务层实现类下的所有方法* com.itheima.service.impl.*.*(..)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!-- 配置srping的Ioc,把service对象配置进来--><bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean><!-- 配置Logger类 --><bean id="logger" class="com.itheima.utils.Logger"></bean><!--配置AOP--><aop:config><!--配置切面 --><aop:aspect id="logAdvice" ref="logger"><!-- 配置通知的类型，并且建立通知方法和切入点方法的关联--><aop:before method="printLog" pointcut="execution(* com.itheima.service.impl.*.*(..))"></aop:before></aop:aspect></aop:config></beans>

别忘了顶头加入xmlns:aop

8.2 四种通知类型

Logger类

package com.itheima.utils;import org.aspectj.lang.ProceedingJoinPoint;/*** 用于记录日志的工具类，它里面提供了公共的代码*/
public class Logger {/*** 前置通知*/public  void beforePrintLog(){System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");}/*** 后置通知*/public  void afterReturningPrintLog(){System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");}/*** 异常通知*/public  void afterThrowingPrintLog(){System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");}/*** 最终通知*/public  void afterPrintLog(){System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");}/*** 环绕通知* 问题：*      当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了。* 分析：*      通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用，而我们的代码中没有。* 解决：*      Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法。*      该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。** spring中的环绕通知：*      它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。*/public Object aroundPringLog(ProceedingJoinPoint pjp){Object rtValue = null;try{Object[] args = pjp.getArgs();//得到方法执行所需的参数System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");return rtValue;}catch (Throwable t){System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");throw new RuntimeException(t);}finally {System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");}}
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!-- 配置srping的Ioc,把service对象配置进来--><bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean><!-- 配置Logger类 --><bean id="logger" class="com.itheima.utils.Logger"></bean><!--配置AOP--><aop:config><!-- 配置切入点表达式 id属性用于指定表达式的唯一标识。expression属性用于指定表达式内容此标签写在aop:aspect标签内部只能当前切面使用。它还可以写在aop:aspect外面，此时就变成了所有切面可用--><aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"></aop:pointcut><!--配置切面 --><aop:aspect id="logAdvice" ref="logger"><!-- 配置前置通知：在切入点方法执行之前执行--><aop:before method="beforePrintLog" pointcut-ref="pt1" ></aop:before><!-- 配置后置通知：在切入点方法正常执行之后值。它和异常通知永远只能执行一个--><aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning><!-- 配置异常通知：在切入点方法执行产生异常之后执行。它和后置通知永远只能执行一个>--><aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing><!-- 配置最终通知：无论切入点方法是否正常执行它都会在其后面执行>--><aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after><!-- 配置环绕通知 详细的注释请看Logger类中--><aop:around method="aroundPringLog" pointcut-ref="pt1"></aop:around></aop:aspect></aop:config></beans>

/*** 测试AOP的配置*/
public class AOPTest {public static void main(String[] args) {//1.获取容器ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");//2.获取对象IAccountService as = (IAccountService)ac.getBean("accountService");//3.执行方法as.saveAccount();}
}

动态代理的invoke方法就相当于执行环绕通知，开启事务就是前置通知，执行操作就是明确的切入点方法调用，回滚操作就相当于异常通知，释放连接就相当于最终通知。其实环绕通知就是手动设置增强方法何时调用。

8.3 spring基于注解的AOP

  • 在Accountservice上加@service，在logger上加@component（别的不合适，详细解释在注解那里，哪一层就用哪个注解）
  • 在Logger上加@Aspect，分别在通知上加上相应注解@Before（“”）@AfterReturning（“”）@AfterThrowing（“”）@After（“”）
    spring注解四个通知调用顺序有问题，框架的锅，建议用环绕注解，如下，环绕通知引用切面表达式要加（）不然报错。
  • 加一个方法表示切入面表达式，@Pointcut指定切入面表达式
@Component("logger")
@Aspect//表示当前类是一个切面类
public class Logger {@Pointcut("execution(* com.itheima.service.impl.*.*(..))")private void pt1(){}/*** 环绕通知* 问题：*      当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了。* 分析：*      通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用，而我们的代码中没有。* 解决：*      Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法。*      该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。** spring中的环绕通知：*      它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。*/@Around("pt1()")public Object aroundPringLog(ProceedingJoinPoint pjp){Object rtValue = null;try{Object[] args = pjp.getArgs();//得到方法执行所需的参数System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");return rtValue;}catch (Throwable t){System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");throw new RuntimeException(t);}finally {System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");}}
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:aop="http://www.springframework.org/schema/aop"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><!-- 配置spring创建容器时要扫描的包--><context:component-scan base-package="com.itheima"></context:component-scan><!-- 配置spring开启注解AOP的支持 --><aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

8.4 spring基于xml的声明式事务控制

spring提供了事务控制transactionManager，配置即可。
在这里插入图片描述

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:aop="http://www.springframework.org/schema/aop"xmlns:tx="http://www.springframework.org/schema/tx"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!-- 配置业务层--><bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"><property name="accountDao" ref="accountDao"></property></bean><!-- 配置账户的持久层--><bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"><property name="dataSource" ref="dataSource"></property></bean><!-- 配置数据源--><bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"><property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property><property name="url" value="jdbc:mysql://localhost:3306/myspring?serverTimezone=UTC&amp;useUnicode=true&amp;characterEncoding=utf8"></property><property name="username" value="root"></property><property name="password" value="root"></property></bean><!-- spring中基于XML的声明式事务控制配置步骤1、配置事务管理器2、配置事务的通知此时我们需要导入事务的约束 tx名称空间和约束，同时也需要aop的使用tx:advice标签配置事务通知属性：id：给事务通知起一个唯一标识transaction-manager：给事务通知提供一个事务管理器引用3、配置AOP中的通用切入点表达式4、建立事务通知和切入点表达式的对应关系5、配置事务的属性是在事务的通知tx:advice标签的内部--><!-- 配置事务管理器 --><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"></property></bean><!-- 配置事务的通知--><tx:advice id="txAdvice" transaction-manager="transactionManager"><!-- 配置事务的属性isolation：用于指定事务的隔离级别。默认值是DEFAULT，表示使用数据库的默认隔离级别。propagation：用于指定事务的传播行为。默认值是REQUIRED，表示一定会有事务，增删改的选择。查询方法可以选择SUPPORTS。read-only：用于指定事务是否只读。只有查询方法才能设置为true。默认值是false，表示读写。timeout：用于指定事务的超时时间，默认值是-1，表示永不超时。如果指定了数值，以秒为单位。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:attributes></tx:advice><!-- 配置aop--><aop:config><!-- 配置切入点表达式--><aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"></aop:pointcut><!--建立切入点表达式和事务通知的对应关系 --><aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor></aop:config></beans>

8.5 spring基于注解的声明式事务控制

spring中基于注解 的声明式事务控制配置步骤
1、配置事务管理器
2、开启spring对注解事务的支持
3、在需要事务支持的地方使用@Transactional注解

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:aop="http://www.springframework.org/schema/aop"xmlns:tx="http://www.springframework.org/schema/tx"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd">
<!-- 开启spring对注解事务的支持-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
<!-- 其他省略-->

@Service("accountService")
@Transactional(propagation= Propagation.SUPPORTS,readOnly=true)//只读型事务的配置
public class AccountServiceImpl implements IAccountService{

读写性事务控制就需要在每个读写方法上配置@Transactional里readOnly为false

9. jdbcTemplate使用

它是 spring 框架中提供的一个对象，是对原始 Jdbc API 对象的简单封装。spring 框架为我们提供了很多
的操作模板类。
操作关系型数据的：JdbcTemplate HibernateTemplate
操作 nosql 数据库的：RedisTemplate
操作消息队列的：JmsTemplate
jdbcTemplate在 spring-jdbc-5.0.2.RELEASE.jar 中，我们在导包的时候，除了要导入这个 jar 包 外，还需要导入一个 spring-tx-5.0.2.RELEASE.jar（它是和事务相关的）。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.itheima</groupId><artifactId>day04_eesy_01jdbctemplate</artifactId><version>1.0-SNAPSHOT</version><packaging>jar</packaging><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.0.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.0.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-tx</artifactId><version>5.0.2.RELEASE</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.6</version></dependency></dependencies>
</project>
  1. spring中提供了JdbcDaoSupport类，可直接继承使用其中getJdbcTemplate()来crud
public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {@Overridepublic Account findAccountById(Integer accountId) {List<Account> accounts = super.getJdbcTemplate().query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);return accounts.isEmpty()?null:accounts.get(0);}@Overridepublic Account findAccountByName(String accountName) {List<Account> accounts = super.getJdbcTemplate().query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);if(accounts.isEmpty()){return null;}if(accounts.size()>1){throw new RuntimeException("结果集不唯一");}return accounts.get(0);
  1. 使用注解开发时也可自己定义jdbcTemplate类来继承，@Autowired注入
@Repository
public class AccountDaoImpl implements IAccountDao {@Autowiredprivate JdbcTemplate jdbcTemplate;@Overridepublic Account findAccountById(Integer accountId) {List<Account> accounts = jdbcTemplate.query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);return accounts.isEmpty()?null:accounts.get(0);}
public class JdbcDaoSupport {private JdbcTemplate jdbcTemplate;public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {this.jdbcTemplate = jdbcTemplate;}public JdbcTemplate getJdbcTemplate() {return jdbcTemplate;}public void setDataSource(javax.sql.DataSource dataSource) {if(jdbcTemplate == null){jdbcTemplate = createJdbcTemplate(dataSource);}}private JdbcTemplate createJdbcTemplate(DataSource dataSource){return new JdbcTemplate(dataSource);}
}

<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 配置账户的持久层--><bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"><!--<property name="jdbcTemplate" ref="jdbcTemplate"></property>--><property name="dataSource" ref="dataSource"></property></bean><!--配置JdbcTemplate<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/eesy"></property><property name="username" value="root"></property><property name="password" value="1234"></property></bean>
</beans>

这篇关于SSM---------------------Spring的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/941236。

相关文章

Java实现检查多个时间段是否有重合

Java实现检查多个时间段是否有重合

《Java实现检查多个时间段是否有重合》这篇文章主要为大家详细介绍了如何使用Java实现检查多个时间段是否有重合,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录流程概述步骤详解China编程步骤1：定义时间段类步骤2：添加时间段步骤3：检查时间段是否有重合步骤4：输出结果示例代码结语作
阅读更多...
Java中String字符串使用避坑指南

Java中String字符串使用避坑指南

《Java中String字符串使用避坑指南》Java中的String字符串是我们日常编程中用得最多的类之一,看似简单的String使用,却隐藏着不少“坑”,如果不注意,可能会导致性能问题、意外的错误容... 目录8个避坑点如下：1. 字符串的不可变性：每次修改都创建新对象2. 使用 == 比较字符串，陷阱满
阅读更多...
Java判断多个时间段是否重合的方法小结

Java判断多个时间段是否重合的方法小结

《Java判断多个时间段是否重合的方法小结》这篇文章主要为大家详细介绍了Java中判断多个时间段是否重合的方法,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录判断多个时间段是否有间隔判断时间段集合是否与某时间段重合判断多个时间段是否有间隔实体类内容public class D
阅读更多...
IDEA编译报错“java: 常量字符串过长”的原因及解决方法

IDEA编译报错“java: 常量字符串过长”的原因及解决方法

《IDEA编译报错“java:常量字符串过长”的原因及解决方法》今天在开发过程中,由于尝试将一个文件的Base64字符串设置为常量,结果导致IDEA编译的时候出现了如下报错java:常量字符串过长,... 目录一、问题描述二、问题原因2.1 理论角度2.2 源码角度三、解决方案解决方案①：StringBui
阅读更多...
Java覆盖第三方jar包中的某一个类的实现方法

Java覆盖第三方jar包中的某一个类的实现方法

《Java覆盖第三方jar包中的某一个类的实现方法》在我们日常的开发中,经常需要使用第三方的jar包,有时候我们会发现第三方的jar包中的某一个类有问题,或者我们需要定制化修改其中的逻辑,那么应该如何... 目录一、需求描述二、示例描述三、操作步骤四、验证结果五、实现原理一、需求描述需求描述如下：需要在
阅读更多...
Java中ArrayList和LinkedList有什么区别举例详解

Java中ArrayList和LinkedList有什么区别举例详解

《Java中ArrayList和LinkedList有什么区别举例详解》：本文主要介绍Java中ArrayList和LinkedList区别的相关资料,包括数据结构特性、核心操作性能、内存与GC影... 目录一、底层数据结构二、核心操作性能对比三、内存与 GC 影响四、扩容机制五、线程安全与并发方案六、工程
阅读更多...
JavaScript中的reduce方法执行过程、使用场景及进阶用法

JavaScript中的reduce方法执行过程、使用场景及进阶用法

《JavaScript中的reduce方法执行过程、使用场景及进阶用法》：本文主要介绍JavaScript中的reduce方法执行过程、使用场景及进阶用法的相关资料,reduce是JavaScri... 目录1. 什么是reduce2. reduce语法2.1 语法2.2 参数说明3. reduce执行过程
阅读更多...
如何使用Java实现请求deepseek

如何使用Java实现请求deepseek

《如何使用Java实现请求deepseek》这篇文章主要为大家详细介绍了如何使用Java实现请求deepseek功能,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录1.deepseek的api创建2.Java实现请求deepseek2.1 pom文件2.2 json转化文件2.2
阅读更多...
Java调用DeepSeek API的最佳实践及详细代码示例

Java调用DeepSeek API的最佳实践及详细代码示例

《Java调用DeepSeekAPI的最佳实践及详细代码示例》：本文主要介绍如何使用Java调用DeepSeekAPI,包括获取API密钥、添加HTTP客户端依赖、创建HTTP请求、处理响应、... 目录1. 获取API密钥2. 添加HTTP客户端依赖3. 创建HTTP请求4. 处理响应5. 错误处理6.
阅读更多...
Spring AI集成DeepSeek的详细步骤

Spring AI集成DeepSeek的详细步骤

《SpringAI集成DeepSeek的详细步骤》DeepSeek作为一款卓越的国产AI模型,越来越多的公司考虑在自己的应用中集成,对于Java应用来说,我们可以借助SpringAI集成DeepSe... 目录DeepSeek 介绍Spring AI 是什么？1、环境准备2、构建项目2.1、pom依赖2.2
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2