Spring笔记 整合SSM[Struts2框架] 万神小栈

于 2022-10-30 14:31:35 发布
阅读量466 收藏
点赞数
分类专栏： SSM 文章标签： spring struts mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010654175/article/details/127599301
版权

一 spring概述

1.1 web项目开发中的耦合度问题

微信小程序搜索 万神小栈 更多资源等你发现！ 如果文章对你有帮助别忘了点赞加关注喔~

  • 在servlet中需要调用service中的方法，则需要在servlet类中通过new关键字创建service 的实例

  • public interface productService{
  public list<product> list products();
}

  • public class productServiceImpl1 implements ProductService{
  public list<Product> listOriducts(){
    //查询热销商品
  }
}

  • public class productServiceImpl2 implements ProductService{
  public list<Product> listOriducts(){
    //查询好评商品
  }
}

  • public class ProductListServlet extends HttpServlet{
  //在servlet中使用new 关键字 创建 productServiceImpl 对象
  //增加了servlet和service的耦合度
}

  • 在service实现类中需要调用DAO中的方法，也需要在service实现类通过new关键字创建DAO实现类对象

  • 如果在使用new关键字创建对象 则会导致以下问题：

    • 失去了面向接口编程的灵活性
    • 代码的侵入性增强(增加了耦合度) 降低了代码的灵活性
1.2面向接口编程
面向接口编程

解决方案： 在servlet中定义service接口的对象变了，不使用new关键字创建实现类对象，在servlet的实例化的时候，通过反射动态的给service对象变量赋值。

如何实现？ spring可以做到

1.3spring 介绍

spring是一个轻量级的控制反转和面向切面的容器框架，用来解决企业项目开发的复杂度问题–>解藕

  • 轻量级： 体积小，对代码没有侵入性
  • 控制反转：IOC(inverse of Control)，把创建对象的工作交由Spring完成，Spring在创建对象的时候同时可以完成对象属性赋值(DI–>依赖注入)
  • 面向切面：AOP(Aspect Oriented Programming)面向切面编程，可以在不改变原有业务的逻辑的情况下实现对业务的增强
  • 容器： 实例的容器 管理创建的对象

​ spring–>润物细无声没有具体实质性的功能 Mybatis数据库操作 Spring MVC数据接收(控制者) Spring 1.帮助创建管理对象 2.增强项目的业务 --> 帮助别人的框架使用更方便

1.4 Spring架构图

1.4.1 Core Container

Spring容器组件，用于完成实例的创建和管理

  • Core 核心
  • beans 依赖于核心 做对象管理或 实例管理
  • Context Spring上下文或容器上下文
1.4.2 AOP Aspects

上面两个组成Spring AOP组件 实现面向切面编程

  • AOP
  • Aspects
1.4.3 web

Spring web组件 实际上指的是 Spring MVC框架，实现web项目的MVC控制

  • web组件(Spring对web项目的支持)
  • web MCVC (Spring MVC组件)
1.4.4 Data Access

Spring 数据访问组件 也是基于JDBC封装的持久层框架(即使没有Mybatis Spring也可以完成持久化)

  • tx 事物管理组件
1.4.5 Test

Spring的单元测试组件 提供了Spring环境下的单元测试支持

  • test

二 Spring Ioc

Spring ioc 容器组件，可以完成对象的创建 对象属性赋值 对象管理

2.1 Spring 框架部署(ioc)
2.1.1 创建Maven工程
  • Java
  • web
2.1.2添加 Spring ioc依赖
  • core
  • beans
  • aop
  • express
  • counext 导入之后不需要到入其他的了
 				<!--Spring beans-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.2.13.RELEASE</version>
        </dependency>
        <!--Spring core-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.2.13.RELEASE</version>
        </dependency>
        <!--Spring context-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.13.RELEASE</version>
				</dependency>
2.1.3 创建Spring 配置文件

通过配置文件“告诉” Spring 容器创建什么对象 给对象属性赋什么值

  • 在resource目录下 创建名为 applictionCountext.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">
    <!--对于一个xml文件如果作为框架的配置文件，需要遵守框架的配置规则-->
    <!--通常一个框架为了让开发者能够正确配置，都会提供xml的规范文件(dtd/xsd)-->
        
</beans>
2.2 spring ioc使用

使用Springioc 组件创建并管理对象

2.2.1创建一个类
/**
 * @author WanShen
 * @date 2022年02月24日 11:30 PM
 */
public class Student {
    private String stuNum;
    private int stuAge;
    private String stuSex;
    private Date enterenceTime; //入学日期
}
2.2.2在Spring配置文件中配置实体类
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--通过bean将实体类配置给Spring进行管理 ID表示 实体类的唯一标识-->
      <bean id="student" class="com.bean.Student">
          <property name="stuNum" value="张三" />
          <property name="stuAge" value="13" />
          <property name="stuSex" value="男" />
      </bean>
</beans>
2.2.3初始化Spring对象工厂，获取对象
  • ClassPathXmlApplicationContext
 //通过Spring容器创建student对象
        //1.初始化Spring容器
        ClassPathXmlApplicationContext context= new 							ClassPathXmlApplicationContext("applicationContext.xml");
        //2.通过Spring容器获取student对象
        Student student = (Student) context.getBean("student");
        System.out.println(student);
2.3ioc和DI
  • ioc(inverse of Control)控制反转，依赖Spring对象工厂完成对象的创建–>工厂设计模式
  • DI(dependency injection) 依赖注入，在Spring完成对象创建的同时依赖Spring容器完成对象属性的赋值
2.3.1 ioc

当我们需要通过Spring对象工厂创建某个累的对象的时候，需要将这个类交给Spring管理–>通过bean标签配置

 <bean id="student" class="com.bean.Student"></bean>
 <bean id="bool" class="com.bean.Book"></bean>
2.3.2 DI

通过Spring容器给创建的对象属性赋值

<bean id="student" class="com.bean.Student">
          <property name="stuNum" value="张三" />
          <property name="stuAge" value="13" />
          <property name="stuSex" value="男" />
          <property name="enterenceTime" ref="date" />
</bean>
2.4 DI依赖注入
2.4.1依赖注入三种方式

Spring容器加载配置文件之后通过反射创建类的对象，并给属性赋值;Spring通过反射实现属性注入有三种方式：

  • set方法注入
  • 构造器注入
  • 接口注入(不常用)
2.4.2 set方法注入

在bean标签中通过配置property标签给对象属性赋值，实际上就是通过反射调用set方法完成属性的注入

简单类型及字符串简单类型指String double这些

  • 直接通过property标签的value属性赋值

日期对象

  • 方式1:在property标签中通过ref引用Spring
 <bean id="student" class="com.bean.Student">
          <property name="enterenceTime" ref="date" />
      </bean>
    <bean id="date" class="java.util.Date"/>
  • 方式2: 在property标签中添加子标签bean来指定对象
<bean id="student" class="com.bean.Student">
   <property name="enterenceTime">
     <bean class="java.util.Date" />
   </property>
</bean>

集合类型

  • List

    • List List中的元素是字符串或者简单类型的封装类
    <property name="hobbit" value="看电影,旅游" />

    <property name="hobbit">
   <list>
      <value>看电影</value>
      <value>旅游</value>
   </list>
</property>
    • ListList中的元素是对象类型
    <property name="hobbit">
              <list>
                  <bean class="com.bean.ClassZz" />
                  <bean class="com.bean.ClassZz" />
                  <bean class="com.bean.ClassZz" />
              </list>
 </property>
    • 第二种方法： 上面定义bean cls引用
    <property name="hobbit">
              <list>
                 <ref bean="cls"></ref><!--引用容器中的bean-->
                <ref bean="cls"></ref>
                <ref bean="cls"></ref>
              </list>
 </property>

  • set

  • <property name="classZz">
	<set>
		<!--和List元素注入方式相同-->
	</set>
</property>

  • Map

  • <property name="map">
            <map>
                <entry>
                   <key>
                       <value>k1</value>
                   </key>
                    <value>123</value>
                </entry>
                <entry>
                    <key>
                        <value>k2</value>
                    </key>
                    <value>456</value>
                </entry>
            </map>
        </property>

  • Properties 可以直接给键值对 (String类型)

<property name="properties">
              <props>
                  <prop key="k1">123</prop>
                  <prop key="k2">456</prop>
              </props>
          </property>
2.4.3 构造器注入

使用被Spring管理的类的构造器来完成属性的赋值 常用set方法注入 构造器注入使用少

简单类型 字符串 对象 需要对应顺序 可以使用index索引

<bean id="cls" class="com.bean.ClassZz"></bean>
<bean id="stu" class="com.bean.Student">
       <constructor-arg value="张三" />
  <!--<constructor-arg index="0" value="张三" />-->
       <constructor-arg value="18" />
       <constructor-arg value="男" />
       <constructor-arg value="162.5" />
        <constructor-arg>
            <bean class="java.util.Date"></bean>
        </constructor-arg>
        <constructor-arg ref="cls" />
</bean>

集合类型属性：

public class Student{
    private List<String> hobbit; //爱好
    private  Properties properties;
    private  Map map;
    private Set set;
  
      public Student(Properties properties, Map map, Set set) {
        this.properties = properties;
        this.map = map;
        this.set = set;
    }
  
}

  <bean id="stu1" class="com.bean.Student">
        <constructor-arg>
            <list>
                <value>111list</value>
            </list>
        </constructor-arg>
        <constructor-arg>
            <map>
                <entry>
                    <key><value>key1</value></key>
                    <value>values1</value>
                </entry>
            </map>
        </constructor-arg>
        <constructor-arg>
            <set>
                <value>set集合</value>
            </set>
        </constructor-arg>
        <constructor-arg>
            <props>
                <prop key="key22">propers</prop>
            </props>
        </constructor-arg>
    </bean>
2.5 bean的作用域

在bean标签中可以通过scope属性 指定对象的作用域

  • scope=“singleton” 表示当前bean是单例模式(默认饿汉模式，Spring容器初始化阶段就会完成此对象的创建;当在bean标签中设置lazy-init=“true”变为懒汉模式)
  • scope=“prorotype”表示当前bean为非单例模式，每次通过Spring容器获取此bean对象的时候都会创建一个新的对象

  • 单例

  • <bean id="cls" class="com.bean.ClassZz" scope="singleton" lazy-init="true"></bean>

  • 多例

  • <bean id="cls" class="com.bean.ClassZz" scope="prototype"></bean>
2.6 bean的生命周期方法

​ 在Bean标签中通过init-method属性指定当前bean的初始化方法 初始化方法在构造器之后执行
​ 在Bean标签中通过destroy-method=属性指定当前bean的销毁方法 销毁方法在对象销毁之前执行

  • Bean类
package com.bean;

/**
 * @author WanShen
 * @date 2022年02月26日 4:28 PM
 */
public class Book {
    private int bookId;
    private String bookName;

    public void init(){
        System.out.println("------init");
        this.bookId=1;
        this.bookName="初始值";
    }
    public void destroy(){
        System.out.println("销毁！");
    }
    public Book() {
    }

    @Override
    public String toString() {
        return "Book{" +
                "bookId=" + bookId +
                ", bookName='" + bookName + '\'' +
                '}';
    }
}
  • Spring配置文件
<bean id="book" class="com.bean.Book" scope="prototype" init-method="init" destroy-method="destroy"></bean>
2.7 自动装配

自动装配： Spring在实例化当前Bean的时候从Spring容器中找到匹配的实例赋值给当前Bean的属性

  • byName 根据当前bean的属性名在Spring容器中·寻找匹配的对象 如果根据name找到了bean但是类型不匹配则抛出异常
  • byType 根据当前bean的属性类型在Spring容器中寻找匹配的对象 如果根据类型找到了多个类型匹配的bean也会抛出异常
    <bean id="student" class="com.bean.Student" autowire="byName" ></bean>
    <bean id="student" class="com.bean.Student" autowire="byType" ></bean>
2.8 Spring 工作原理

三 Spring Ioc-基于注解

Spring ioc的使用需要我们通过xml将类声明给Spring容器进行管理从而通过Spring工厂完成对象的创建及属性值的注入;

Spring除了提供基于xml的配置方式，同时提供了基于注解的配置，直接在实体类中添加注解声明给Spring容器管理 以简化开发步骤

3.1 Spring 框架部署
3.1.1创建maven 项目

略过

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.13.RELEASE</version>
</dependency>
3.1.2 创建xml配置文件
  • 因为Spring容器初始化时，只会加载applicationConetx.xml 那么我们在实体类中添加的注解就不会被Spring扫描 所以我们需要在applicationContext.xml声明Spring的扫描范围，以达Spring初始化时扫描带有注解的实体类并完成初始化工作。
<?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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!--声明使用注解-->
    <context:annotation-config/>
    <!--    声明Spring工厂注解的扫描范围-->
    <context:component-scan base-package="com.beans"/>

</beans>
3.2 ioC常用注解
3.2.1 @Component
  • 类注解,声明此类被Spring容器进行管理,相当于bean标签的作用
  • @Component(value="stu")value属性用于指定当前bean的id,相当于bean标签的id属性;value属性也可以省略,如果省略 当前类的id默认为类名首字母改小写
  • 除了@Compent之外 @Service、@Controller、@Repository这三个注解也可以将类声明Spring管理,他们主要是语义上的区别
    • @Controller注解 主要声明将控制器类配置给Spring管理,例如Servlet
    • @Service注解 主要声明业务处理类配置给Spring管理,Service接口的实现类
    • @Respository 注解 主要声明持久化类配置给Spring管理，DAO接口
    • @Component 除了控制器、service和DAO之外的类一律使用此注解声明
3.2.2 @Scope注解
  • 类注解： 写在类上面的注解叫 类注解 用于声明当前类单例模式还是非单例模式 相当于bean标签的scope属性
  • @Scope(“prototype”)表示声明当前类为非单例模式(默认单例模式)
3.2.3@Lazy注解
  • 类注解：用于声明一个单例模式的Bean是否为懒汉模式
  • @Lazy(true)表示声明为懒汉模式,默认为饿汉模式
3.2.4 @PostConstruct
  • 方法注解： 声明一个方法为当前类的初始化方法(在构造器之后执行),相当于bean标签的init-method属性
3.2.5 @PreDestroy
  • 方法注解：声明一个方法为当前类的销毁化方法(在对象从容器中释放之前执行),相当于bean标签的destroy-method属性
3.2.6 @Autowired

  • 属性注解，方法注解(set方法) 声明当前属性自动装配,默认byType

  • @Autowired(required = false) 通过required属性设置当前自动装配是否为必须 默认必须(如果没有找到类型与属性类型匹配的bean则抛出异常)

    • byType
    • ref引用
    @Autowired
    public void setClazz(@Qualifier("c1") Clazz clazz) {
        this.clazz = clazz;
    }
3.2.7 @Resource
  • 属性注解：也用于声明属性自动装配
  • 默认装配方式为byName,如果根据byName没有找到对应的bean,则继续根据byType继续寻找对应的bean根据byType如果依然没有找到bean或者找到不止一个类型匹配的bean则抛出异常。

四、代理设计模式

5.1 生活中的代理

代理设计模式的优点：将通用性的工作都交给代理对象完成✅ 被代理对象只需专注自己的核心业务。

5.2 静态代理

静态代理,代理类只能够为特定的生产代理对象,不能代理任意类

流程: BookDAO(接口) BookDAOImpl(接口实现类) Myproxy(代理类)

​ 两个以上的话 代理类封装接口–>提供有参构造方法–> 通过代理可以两个类切换

使用代理的好处

  1. 被代理类中只用关注核心业务的实现,将通用的管理型逻辑(事务管理、日志管理)和业务逻辑分离—>高内聚 低耦合
  2. 将通用的代码放在代理类中实现，提高了代码的复用性。
  3. 通过在代理类添加业务逻辑,实现对原有业务逻辑的拓展(增强)
5.3 动态代理

动态代理,几乎可以为所有的类产生代理对象

动态代理的实现方式有2种：

  • JDK动态代理
  • CGLIB动态代理
  • JDK动态代理类实现：
package com.dao;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @author WanShen
 * @date 2022年03月07日 11:07 PM
 * JDK动态代理：是通过被代理对象实现的接口产生其代理对象的
 *  1.创建一个类,实现InvocationHandler 重写invoke方法
 *  2.在类中定义一个Object类型的变量，用于传递被代理对象 并提供这个对象的有参构造器
 *      用于将被代理的类传递进来
 *  3.定义getProxy()方法 用于创建返回对象
 *  4.重写invoke方法;
 */
public class JDKDynamicProxy implements InvocationHandler {
 //    被代理对象
    private Object object;

    public JDKDynamicProxy(Object object) {
        this.object = object;
    }

    //    产生代理对象,返回代理对象
    public Object getProxy() {
//        1.获取被代理对象的类加载器
        ClassLoader classLoader = object.getClass().getClassLoader();
//        2.获取被代理对象的类实现的接口
        Class<?>[] interfaces = object.getClass().getInterfaces();
//        3.产生代理对象(通过被代理对象的类加载器以及实现的接口)
//        第一个参数：被代理对象的类加载器
//        第二个参数：被代理对象实现的接口
//        第三个参数：使用产生的代理对象调用方法时用于拦截方法执行时的处理器
        Object proxy = Proxy.newProxyInstance(classLoader, interfaces, this);
        return proxy;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object returnValue = null;
        try {
//            方法执行前
            begin();
            returnValue = method.invoke(object, args);
//            方法执行后
            commit();
        } catch (Exception e) {
            e.printStackTrace();
//            发生异常后
            rollback();
        }

        return returnValue;
    }

    public void begin() {
        System.out.println("--开启事务");
    }

    public void commit() {
        System.out.println("--提交事物");
    }

    public void rollback() {
        System.out.println("--回滚事务");
    }
  • 测试：
//        被代理对象
        BookDapImpl bookDao = new BookDapImpl();
//        创建动态代理类对象，并将代理类对象传递到代理类中赋值给obj
        JDKDynamicProxy jdkDynamicProxy = new JDKDynamicProxy(bookDao);

//          proxy就是产生的代理对象：可以强转成被代理对象实现的接口类型
        GeneralDAO proxy = (GeneralDAO) jdkDynamicProxy.getProxy();
//            使用代理对象调用方法,并不会执行调用的方法,而是进入到创建代理对象时指定的InvocationHandler类中的invoke方法
//       调用的方法作为一个Method参数给了invoke方法
        proxy.delete();

**限制：**只能为实现了接口的类产生代理;

4.3.2 CGLib动态代理

由于JDK动态代理是通过被代理类实现的接口来创建代理对象的，因此JDK动态代理只能代理实现了接口的类的对象.如果一个类没有任何实现接口该如何产生代理对象呢？

CGLib动态代理，是通过创建被代理类的子类来创建代理对象的,因此 即使没有实现任何接口的类也可以通过CGLib产生代理对象，CGLib动态代理 不能为final类创建代理对象;

  • 添加CGLib的依赖
   <!-- https://mvnrepository.com/artifact/cglib/cglib -->
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>
  • CGLib动态代理实现：
package com.dao;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @author WanShen
 * @date 2022年03月08日 12:36 PM
 * 1.添加CGLib依赖
 * 2.创建一个类,实现MethodInterceptor接口 同时实现interceptor方法
 * 3.在类中定义一个Object类型的变量 并提供这个变量的有参构造器,用于传递被代理对象
 * 4.定义getProxy方法创建并返回代理对象(代理对象是通过创建被代理类的子类来创建的)
 */
public class CGLibDynamicProxy implements MethodInterceptor {
    private Object object;

    public CGLibDynamicProxy(Object object) {
        this.object = object;
    }
    public Object getProxy(){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(object.getClass());
        enhancer.setCallback(this);
        Object proxy = enhancer.create();
        return proxy;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        begin();
        Object returnValue = method.invoke(object,objects);
        commit();
        return returnValue;
    }
    public void begin(){
        System.out.println("--开启事务");
    }
    public void commit(){
        System.out.println("--提交事物");
    }
}
  • 测试：
//        被代理对象
        BookDapImpl bookDao = new BookDapImpl();
//通过CGLib动态代理类创建代理对象
        CGLibDynamicProxy cgLibDynamicProxy = new CGLibDynamicProxy(new BookDapImpl());
//代理对象实际上是被代理对象的子类，因此代理对象可以直接强转为被代理类类型
        BookDapImpl proxy = (BookDapImpl) cgLibDynamicProxy.getProxy();
//使用对象调用方法，实际上并没有执行这个方法,而是执行了代理类中的intercept方法 将当前调用的方法的参数传递到intercept方法
        proxy.delete();

五、Spring Aop

5.1 AOP概念

Aspect Oriented Programming面向切面编程,是一种利用“横切”的技术(底层实现就是动态代理) 对原有的业务逻辑进行拦截,并且可以在这个拦截的横切面上添加特定的业务逻辑,对原有的业务进行增强。

基于动态代理实现在不改变原有业务的情况下对业务逻辑进行增强

5.2 Spring AOP框架部署
5.2.1 创建Maven项目
5.2.2添加依赖
  • context
  • aspects
     <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.13.RELEASE</version>
        </dependency>
       
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.13.RELEASE</version>
        </dependency>
5.2.3 创建Spring配置文件
  • 需要引入AOP的命名空间
<?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/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

</beans>
5.3 AOP配置-基于xml

在DAO的方法添加开启事物和提交事物的逻辑

5.3.1 创建一个类,定义要添加的业务逻辑
package com.utils;

/**
 * @author WanShen
 * @date 2022年03月08日 5:42 PM
 */
public class TxManger {
    public void begin(){
        System.out.println("开启事务");
    }
    public  void commit(){
        System.out.println("提交食物");
    }
}
5.3.2 配置AOP
<aop:pointcut id="book_all" expression="execution(* com.dao.*.*(..))"/>
execution(* com.dao.*.*(..))
第一个 * 是 所有返回类型
第二个 * 是com.dao下所有的类的所有方法

<?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/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean class="com.dao.BookDapImpl" id="bookDap"></bean>
<bean id="txManger" class="com.utils.TxManger"></bean>
   <aop:config>
       <!--声明切入点-->
       <aop:pointcut id="book_all" expression="execution(* com.dao.*.*(..))"/>
       <!--声明txManger为切面类-->
       <aop:aspect ref="txManger">
           <!--通知-->
           <aop:before  method="begin" pointcut-ref="book_all" />
           <aop:after method="commit" pointcut-ref="book_all" />
       </aop:aspect>
   </aop:config>
</beans>

AOP开发步骤:

  1. 创建切面类,在切面类定义切点方法
  2. 将切面类配置给Spring容器
  3. 声明切入点
  4. 配置AOP的通知策略
5.4 切入点的声明：
<!--使用aop:pointcut标签声明切入点: 切入点可以是一个方法-->
        <aop:pointcut id="book_pc1" expression="execution(* com.dao.BookDapImpl.insert())"/>
        <!--BookDapImpl类中 类中所有无参数无返回值的方法-->
        <aop:pointcut id="book_pc2" expression="execution(void com.dao.BookDapImpl.*())"/>
        <!--BookDapImpl类 中所有无返回值的方法-->
        <aop:pointcut id="book_pc3" expression="execution(void com.dao.BookDapImpl.*(..))"/>
        <!--BookDapImpl类 中所有无参数的方法-->
        <aop:pointcut id="book_pc4" expression="execution(* com.dao.BookDapImpl.*())"/>
        <!--BookDapImpl类 中的所有方法-->
        <aop:pointcut id="pc5" expression="execution(* com.dao.BookDapImpl.*(..))"/>
        <!--dao包中所有类的所有方法-->
        <aop:pointcut id="pc6" expression="execution(* com.dao.*.*(..))"/>
        <!--所有包中所有类的所有方法-->
        <aop:pointcut id="pc7" expression="execution(* *(..))"/>
5.4.2 AOP使用注意事项：

如果要使用Spring aop切面编程,调用切入点方法的对象必须通过Spring容器获取

​ 如果一个类中的方法被声明为切入点之后, 通过spring容器获取对象 实则获取到的是一个代理对象。

​ 如果一个类中的方法没有被声明为切入点，通过Spring容器获取的就是这个类真实创建的对象。

5.5 AOP通知策略

AOP通知策略： 就是声明将切面类中的切点方法如何织入到切入点

5.5.1 定义切面类
package com.utils;

/**
 * @author WanShen
 * @date 2022年03月08日 5:42 PM
 */
public class TxManger {
    public void begin(){
        System.out.println("开启事务");
    }
    public  void commit(){
        System.out.println("提交事物");
    }
}
5.5.2 配置切面类
 <aop:config>
        <!--所有包中所有类的所有方法-->
        <aop:pointcut id="pc7" expression="execution(* *(..))"/>
        <!--声明txManger为切面类-->
        <aop:aspect ref="txManger">
            <!--aop:before 前置通知 切入到指定切点之前-->
            <aop:before  method="begin" pointcut-ref="pc7" />
            <!--aop:before 后置通知 切入到指定切点之后-->
            <aop:after  method="begin" pointcut-ref="pc7" />
            <!--aop:after-throwing 异常通知 切入点抛出异常之后-->
            <aop:after-throwing  method="begin" pointcut-ref="pc7" />
            <!--aop:after-returning 方法返回值之后,对于一个java方法而言
            return返回值也是方法的一部分因此"方法返回值返回之后"和"方法执行结束"
            是同一个时间点,所以after和after-returning根据配置的顺序决定执行顺序
            -->
            <aop:after-returning  method="begin" pointcut-ref="pc7" />
                <!--aop:around 环绕通知-->
            <aop:around  method="begin" pointcut-ref="pc7" />
        </aop:aspect>
    </aop:config>

六、Spring AOP注解配置

6.1 Spring AOP注解配置框架部署
6.1.1 创建Maven工程
6.1.2 添加Spring依赖
  • context
  • aspects
6.1.3 Spring配置文件
<?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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--声明使用注解-->
    <context:annotation-config/>
    <!--    声明Spring工厂注解的扫描范围-->
    <context:component-scan base-package="com.dao"/>
    <!--基于注解配置的AOP代理-->
    <aop:aspectj-autoproxy ></aop:aspectj-autoproxy>
</beans>
6.2 AOP注解配置 案例:
package com.utils;

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

/**
 * @author WanShen
 * @date 2022年03月09日 1:42 PM
 */
@Component //声明Spring容器管理此类
@Aspect //声明此类是切面类
public class TransactionManager {
    @Pointcut("execution(* com.dao.*.*(..))")
    public void Pointcut(){}

    @Before("Pointcut()")
    public void begin() {
        System.out.println("开启事物");
    }

    @After("Pointcut()")
    public void commit() {
        System.out.println("提交事物");
    }
    @Around("Pointcut()")
    public Object printExecudate(ProceedingJoinPoint point) throws Throwable {
        long tim1 = System.currentTimeMillis();
        Object v = point.proceed();
        long tim2 = System.currentTimeMillis();
        System.out.println("执行时间:"+(tim2-tim1));
        return v;
    }
}

注意：注解使用虽然方便 但只能在源码上添加注解,因此我们的自定义提倡使用注解配置;如果使用到第三方提供的类则需要通过xml配置形式完成配置。

七、Spring整合MyBatis

Spring 量大核心思想： ioc和aop

ioc： 控制反转, Spring容器可以完成对象的创建、属性注入、对象管理等工作

AOP： 面向切面, 在不修改原有业务逻辑的情况下,实现对原有业务的增强

7.1 Spring可以对MyBatis提供哪些支持？
7.1.1SpringioC
  • 需要创建数据源DataSource
  • 需要创建SqlSessionFactory对象
  • 需要创建sql Session对象
  • 需要创建DAO对象(Mapper)

**IOC支持：**SpringioC可以为Mybatis完成DataSource、SqlSessionFactory、SqlSession以及DAO对象的创建

AOP支持使用Spring提供的事物管理切面类完成对MyBatis数据库操作中的事物管理

7.2 spring整合MyBatis准备工作
7.2.1 创建Maven工程
7.2.2 部署Mybatis框架
  • 添加依赖
    • Mysql驱动
    • Mybatis
  <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
  • 创建MyBatis配置文件创建配置文件之后无需进行配置
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd" >
<configuration>

</configuration>
7.2.3 部署Spring框架
  • 添加依赖
   <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.13.RELEASE</version>
        </dependency>
        <!--切面 aop的支持-->
        <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.2.13.R ELEASE</version>
        </dependency>
				<!--Spring对持久层的支持-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.13.RELEASE</version>
        </dependency>
  • 创建Spring配置文件： applicationContext.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    
</beans>
7.2.4 添加Spring整合Mybatis的依赖
  • Mybatis-Spring 就是Mybatis提供的兼容Spring的补丁
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.2</version>
</dependency>
7.3 Spring整合MyBatis整合配置
7.3.1整合Druid连接池
  • 添加Druid到的依赖
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <!--druid连接池依赖-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.5</version>
        </dependency>
  • 创建Druid.properties属性文件
druid.driver=com.mysql.Driver
druid.url=jdbc:mysql://localhost:3306/date_demo?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false;
druid.username=root
druid.password=admin

# 连接池参数
druid.pool.init=1
druid.pool.minIdle=3
druid.pool.maxActive=20
druid.pool.timeout=30000
  • 在applicationContext.xml中配置DruidDataSource
<?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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--加载druid.properties属性文件-->
    <context:property-placeholder location="classpath:druid.properties" />
		<bean id="driver" class="com.mysql.jdbc.Driver"/>
<!--依赖Spring容器完成对DataSource的创建-->
 <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
      <property name="driver" ref="driver"/>
     <property name="url" value="${druid.url}" />
     <property name="username" value="${druid.username}" />
     <property name="password" value="${druid.password}" />

     <property name="initialSize" value="${druid.pool.init}" />
     <property name="minIdle" value="${druid.pool.minIdle}" />
     <property name="maxActive" value="${druid.pool.maxActive}" />
     <property name="maxWait" value="${druid.pool.timeout}" />
 </bean>
</beans>
7.3.2 整合MyBatis-创建sqlSessionFactory
  <!--依赖Spring容器完成MyBatis的SqlSessionFactory对象创建-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean" autowire="byName">
        <!--配置数据源-->
        <!--        <property name="dataSource" ref="dataSource" />-->
<!--配置Mapper文件的位置/路径-->
        <!--        <property name="mapperLocations" value="classpath:mapper/*Mapper.xml" />-->
<!--配置需要定义别名的实体类的包-->
        <property name="typeAliasesPackage" value="com.wanshen.pojo"/>
        <!--可选：配置Mybatis的主配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>
7.3.3 整合MyBatis-创建Mapper
  <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
        <property name="basePackage" value="com.wanshen.dao" />
    </bean>
7.4 Spring整合MyBatis整合ioC配置

使用Spring提供的事物管理切面类 完成DAO中增删改操作的事物管理

  • propagation:传播属性=> 发生在多个业务之间事物的传递过程

外层实物的概念解释:

一个比较复杂的业务中,往往会出现在一个service方法中,调用其他的service方法(可能是同一类也可能是其他类的service方法)

某个service方法中 s1 s2 s3需要调用s1 s2 那么s3本身就是service中的方法 有事务 s1 s2也有事务

S3相对于S1 s2来讲就是 外层事物

  • isolation 事务隔离

不可重复度=>一方更新导致两次查询结果不一致

7.4.1 事物的隔离级别

isolation 设置事务隔离级别： READ_UNCOMMITTED、READ_COMMITTED、REPEATABLE_READ、SERIALIZABLE

READ_UNCOMMITTED： 读 未提交-> T1在执行的过程中 T2既可以读也可以写 T1可以提取到T2未提交的数据(脏读)、(不可重复读)、(幻读)

READ_COMMITTED： 读 已提交 -> T1在执行的过程中T2可以读也可以写但是T1只能读到T2提交后的数据(不可重复读)、(幻读)

REPEATABLE_READ: 可重复读 -> T1 在执行的过程中T2只能读但不能写 T2可以添加数据(幻读)

SERIALIZABLE：串行化/序列化-> T1 在执行的过程中T2既不能读也不能写

事务的隔离级别越高 会导致事务的安全性高 但是效率降低

7.4.2 事务的传播机制

propagation 事务的传播机制:
REQUIRED 如果上层方法没有事务,则创建一个新的事务 如果已存在事务则加入到事务中.
SUPPORTS 如果上层方法没有事务,则以非事务方式执行 如果已存在事务则加入到事务中.
REQUIRES_NEW 如果上层方法没有事务,则创建一个新的事务 如果已经存在事务,则将当前事务挂起.
NOT_SUPPORTED 如果上层方法没有事务,则以非事务方式执行 如果已存在事务则将当前事务挂起.
NEVER 如果上层方法没有事务,则以非事务方式执行 如果已存在事务则抛出异常.
MANDATORY 如果上层方法已经存在事务,则加入到事务中执行,如果不存在事务则抛出异常
NESTED 如果上层方法没有事务,则创建一个新的事务 如果已存在事务则嵌套到当前事务中.

一般 增删改用REQUIRED 查询用SUPPORTS 日志类用 REQUIRES_NEW

7.4.3 Spring AOP事务管理配置–XML配置
 <!--1.将Spring提供的事务管理类配置给Spring容器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--2.通过Spring提供的tx标签 声明事务管理策略-->
    <tx:advice id="txadvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="insert" isolation="REPEATABLE_READ" propagation="REQUIRED"/>
            <tx:method name="delete" isolation="REPEATABLE_READ" propagation="REQUIRED"/>
            <tx:method name="update" isolation="REPEATABLE_READ" propagation="REQUIRED"/>
            <tx:method name="query" isolation="REPEATABLE_READ" propagation="NOT_SUPPORTED"/>
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <aop:pointcut id="crud" expression="execution(* com.wanshen.dao.*.*(..))"/>
        <aop:advisor advice-ref="txadvice" pointcut-ref="crud" />
    </aop:config>

⚠️注意: 事务在dao中不明智 应在service中 因为一个service中包含多个dao的操作

应该为:

 <aop:pointcut id="crud" expression="execution(* com.wanshen.service.*.*(..))"/>
7.4.4 Spring AOP事务管理配置–注解配置
  • 在applicationContext.xml配置事务管理,声明使用注解方式进行事物配置
<!--1.将Spring提供的事务管理类配置给Spring容器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
<!--2.声明使用注解完成事务配置-->
        <tx:annotation-driven transaction-manager="transactionManager" />
  • 在需要Spring进行事物管理的方法上添加@Transactional注解
package com.wanshen.service;

import com.wanshen.dao.UserDao;
import com.wanshen.pojo.User;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;

/**
 * @author WanShen
 * @date 2022年03月10日 7:21 PM
 */
@Service
public class UserServiceImpl implements UserService {
        @Resource
     private UserDao userDao;
    @Override
    @Transactional(isolation = Isolation.REPEATABLE_READ,propagation = Propagation.SUPPORTS)
    public List<User> listUsers() {
        return userDao.queryUsers();
    }
}

补充知识：log4j（了解）

log4j（log for java）Java的日志框架。

log4j中的概念

日志级别：OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL （从高到低），级别越高，输出的日志越少（比如设置为WARN时，是输出WARN、ERROR和FATAL级别）。

日志分类：根日志（rootLogger，全局日志）、分支日志（logger，包级别的日志），其中根日志必须存在。

log4j的使用

  1. 引入依赖

    <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.25</version>
</dependency>

  2. 配置（必须是src/main/resources/log4j.properties），不需要会写这个配置，能看懂和修改即可

    # 根日志级别ERROR，输出到stdout
log4j.rootLogger=ERROR,stdout
# 设置stdout的输出使用ConsoleAppender（控制台）
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
# 设置stdout的显示方式为PatternLayout（自定义格式）
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
# 设置stdout的格式 %p为日志级别 %t为线程名 %d为日期{格式} %m为主线程日志 %n为换行
log4j.appender.stdout.layout.ConversionPattern=%p [%t] %d{yyyy-MM-dd HH:mm:ss} - %m%n

# 设置com.baizhi.dao包的日志级别为DEBUG，用来输出SQL语句
log4j.logger.com.baizhi.dao=DEBUG

# 推荐开发项目 根级别日志为ERROR
# 输出自己代码中所有的日志信息
log4j.logger.com.baizhi = DEBUG
# 把dao所在的子包设置为ERROR，因为SQL语句帮助不是很大
log4j.logger.com.baizhi.dao = ERROR

  3. 自己使用日志对象来输出日志

    //成员变量中
//参数一般为当前类的类对象
private static final Logger LOGGER = LoggerFactory.getLogger(UserServiceImpl.class);

//想输出日志的地方
LOGGER.debug("debug");
LOGGER.info("info");
LOGGER.warn("warn");
LOGGER.error("error");
//也可以采用{}占位符输出形式
LOGGER.info("name: {}, id: {}", user.getName(), user.getId());

补充知识：MD5加盐加密（Spring版）

加密（了解）

加密，是以某种特殊的算法改变原有的信息数据，使得未授权的用户即使获得了已加密的信息，但因不知解密的方法，仍然无法了解信息的内容。

信息在加密之前称为明文，在加密之后称为密文。

MD5（了解）

严格来说，MD5算法的主要作用不是加密，而是生成数据特征码。这个特征码有以下两个性质：

  • 针对相同的数据，特征码一定是相同的。
  • 针对不同的数据，特征码一般是不同的。

因为数据的种类远远超过特征码能表示的种类，因此存在特征码相同时，数据不同的情况。但实际上重复的概率极低。

MD5加密的缺点：如果对比较短的数据进行加密，会很容易破解。

盐（了解）

对原始数据（明文）前面或后面拼接一段数据，使得明文比较长，在经过MD5加密之后变得不容易破解。这段被用来拼接的数据就叫做盐。

注册和登录的逻辑

  • 注册：接收到用户密码后，先随机生成一个盐，接下来把密码按照这个盐进行MD5加盐加密。同时把盐和加密后的密码存入数据库。
  • 登录：根据用户名查询到密码和盐，把用户输入的密码也加盐加密，如果和数据库中加盐加密后的密码相同，则表示输入正确。

获得字符串的MD5特征码

java代码:

String str = "test";
String md5 = DigestUtils.md5DigestAsHex(str.getBytes());

封装工具类

public static String getSalt(){
    return getSalt(20);
}

public static String getSalt(int size){
    char[] pool = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".toCharArray();
    StringBuilder sb = new StringBuilder();
    Random random = new Random();
    for(int i = 0;i < size;i ++){
        sb.append(pool[random.nextInt(pool.length)]);
    }
    return sb.toString();
}

public static String getPassword(String pass, String salt){
    pass = pass + salt;
    return DigestUtils.md5DigestAsHex(pass.getBytes());
}

补充知识：事务的ACID特性

数据库的事务有ACID特性：

  • 原子性（atomicity）：一个事务中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚到事务开始前的状态，就像这个事务从来没有执行过一样。
  • 一致性（consistency）：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写入的资料必须完全符合所有的预设规则，数据库可以自发性地完成预定的工作。
  • 隔离性（isolation）：数据库允许多个并发事务同时对其数据进行读写的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致的情况。
  • 持久性（durability）：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。

SM整合（Spring框架结合Mybatis框架使用）

1.引入依赖

在spring依赖的基础上，加入以下依赖：

<dependency><!--用来控制事务-->
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency><!--mybatis-->
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.2.8</version>
</dependency>
<dependency><!--mybatis结合spring使用的依赖-->
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>1.3.1</version>
</dependency>
<dependency><!--mysql数据库驱动-->
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.40</version>
</dependency>
<dependency><!--阿里巴巴德鲁伊连接池-->
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.12</version>
</dependency>

2.mybatis相关

建表

CREATE TABLE `t_user` (
  `id` varchar(40) NOT NULL,
  `name` varchar(40) DEFAULT NULL,
  `age` int(3) DEFAULT NULL,
  `bir` datetime NULL DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

实体类

public class User implements Serializable{
    private String id;
    private String name;
    private Integer age;
    private Date bir;
    //构造、getter/setter、toString等
}

dao接口

package com.baizhi.dao;

public interface UserDAO {
    List<User> findAll();
    void save(User user);
}

mapper

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.baizhi.dao.UserDao">
    <select id="findAll" resultType="com.baizhi.entity.User">
        SELECT id,name,age,bir FROM t_user
    </select>
    
    <insert id="save" parameterType="com.baizhi.entity.User">
        INSERT INTO t_user (id, `name`, age, bir) VALUES (#{id}, #{name}, #{age}, #{bir})
    </insert>
</mapper>

mybatis-spring官方整合中不再需要mybatis主配置文件。

3.整合配置文件

<!--引入db小配置文件-->
<context:property-placeholder location="classpath:db.properties"/>

<!--创建数据源对象-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${mysql.driver}"/>
    <property name="url" value="${mysql.url}"/>
    <property name="username" value="${mysql.username}"/>
    <property name="password" value="${mysql.password}"/>
</bean>

<!--创建sqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <!--注入DataSource对象-->
    <property name="dataSource" ref="dataSource"/>
    <!--注入Mapper文件位置-->
    <property name="mapperLocations" value="classpath:com/baizhi/mapper/*.xml"/>
    <!--实体类别名（非必须，建议不使用这个而在Mapper中实体类写上类的全限定名）-->
    <property name="typeAliasesPackage" value="com.baizhi.entity"/>
</bean>

<!--自动注册DAO，自动注册的id为接口首字母小写-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <!--sqlSessionFactoryBean的bean名字-->
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    <!--所有dao接口所在的包名-->
    <property name="basePackage" value="com.baizhi.dao"/>
</bean>

4.启动工厂测试DAO

ApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
UserDAO userDao = (UserDAO) ctx.getBean("userDao");
List<User> users = userDao.findAll();
System.out.println(users);

5.在Service层控制事务

1.Service接口

public interface UserService {
    List<User> findAll();
    void save(User user);
}

2.Service实现类

public class UserServiceImpl implements UserService {
    private UserDAO userDAO;

    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    @Override
    public List<User> findAll() {
        return userDAO.findAll();
    }
    
    @Override
    public void save(User user) {
        userDao.save(user);
    }
}

3.在配置文件中添加

<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<!--配置事务属性，这相当于创建了一个专门完成事务控制的通知对象，这个id就是通知对象的id-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="save*"/>
        <tx:method name="update*"/>
        <tx:method name="delete*"/>
        <tx:method name="find*" propagation="SUPPORTS"/>
        <tx:method name="log*" propagation="REQUIRES_NEW"/>
    </tx:attributes>
</tx:advice>

<!--配置事务切面-->
<aop:config>
    <aop:pointcut id="pc" expression="within(com.baizhi.service.*ServiceImpl)"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pc"/>
</aop:config>

<!--注册所有的Service组件-->
<bean id="userService" class="com.baizhi.service.UserServiceImpl" autowire="byType"/>

事务属性特别说明：

增删改使用默认事务属性、查询使用propagation="SUPPORTS"、日志相关使用propagation="REQUIRES_NEW"是常见的实现，这并不一定符合所有的业务需要。

4.启动工厂测试

ApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
UserService userService = (UserService) ctx.getBean("userService");
User user = new User();
user.setName("test1");
userService.save(user);

SS整合（Spring框架结合Struts2框架使用）

1.引入依赖

在spring依赖的基础上，加入以下依赖：

<!--struts2-->
<dependency>
    <groupId>org.apache.struts</groupId>
    <artifactId>struts2-core</artifactId>
    <version>2.3.16</version>
</dependency>
<!--javaee-->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
    <scope>provided</scope>
</dependency>
<!--jstl-->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>
<!--struts2-spring-plugin 版本号和struts2-core要一致-->
<dependency>
    <groupId>org.apache.struts</groupId>
    <artifactId>struts2-spring-plugin</artifactId>
    <version>2.3.16</version>
</dependency>

2.web.xml配置

<!--设置spring配置文件的位置-->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring.xml</param-value>
</context-param>

<filter>
    <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>

<filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

<!--在项目启动时自动启动spring工厂-->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

3.开发Action类

public class UserAction extends ActionSupport {
    public String hello(){
        System.out.println("action: hello");
        return ActionSupport.SUCCESS;
    }
}

4.工厂管理Action

所有的Action都需要使用工厂创建

<!--配置Action的bean，scope需要为prototype-->
<bean id="userAction" class="com.baizhi.action.UserAction" scope="prototype"/>

5.配置struts.xml

<package name="hello" extends="struts-default" namespace="/hello">
    <!--class为工厂中的名字-->
    <action name="hello" class="userAction" method="hello">
        <result name="success">/index.jsp</result>
    </action>
</package>

6.部署项目测试

创建复杂对象（了解）

复杂对象：类中没有构造方法或者构造方法不能调用，如接口类型或抽象类实例。

package com.baizhi.factorybean;

public class ConnectionFactoryBean implements FactoryBean<Connection> {
    @Override
    //用来指定复杂对象的创建方式(返回创建好的对象)
    public Connection getObject() throws Exception {
        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/ajax", "root", "1234");
        return connection;
    }

    @Override
    //用来指定复杂对象的类型(返回指定复杂对象的类对象)
    public Class<?> getObjectType() {
        return Connection.class;
    }

    @Override
    //用来指定复杂对象的创建次数（返回是否是单例）
    public boolean isSingleton() {
        return false;
    }
}

<bean id="connection" class="com.baizhi.factorybean.ConnectionFactoryBean"/>

SSM整合开发时的重点注意事项（总结）

当使用配置式开发时

  1. spring.xml中手动注册所有的service实现类和action类，在service bean上注入dao，在action bean上注入service。例如：

    <!--注册所有service-->
<bean class="com.baizhi.service.UserServiceImpl" id="userService" autowire="byType"/>
<bean class="com.baizhi.service.CityServiceImpl" id="cityService" autowire="byType"/>
<bean class="com.baizhi.service.AdminServiceImpl" id="adminService" autowire="byType"/>

<!--注册所有action，别忘了scope="prototype"，根据情况，自动注入时也可能是byName-->
<bean class="com.baizhi.action.UserAction" id="userAction" scope="prototype" autowire="byType"/>
<bean class="com.baizhi.action.CityAction" id="cityAction" scope="prototype" autowire="byType"/>
<bean class="com.baizhi.action.AdminAction" id="adminAction" scope="prototype" autowire="byType"/>

  2. 所有service实现类中使用到的所有dao都是成员属性，且提供setter方法，不能通过直接通过getMapper()等形式进行自身管理；所有action类中的使用到的所有service都是成员属性，且提供setter方法，不能直接通过new XxxServiceImpl()等形式进行自身管理。例如：

    public class UserServiceImpl implements UserService{
    private UserDao userDao;
    private CityDao cityDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void setCityDao(CityDao cityDao) {
        this.cityDao = cityDao;
    }
}

public class UserAction{
    private UserService userService;
    private CityService cityService;

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public void setCityService(CityService cityService) {
        this.cityService = cityService;
    }
}

  3. 事务属性name写成save*、update*、delete*、log*、find*并不是固定代码，这么写的前提是：

    • 所有service中的所有添加方法均以save开头
    • 所有service中的所有更新方法均以update开头
    • 所有service中的所有删除方法均以delete开头
    • 所有service中的所有日志记录方法均以log开头
    • 所有service中的所有查询方法均以find开头

  4. struts.xml中的class不要写全限定名而是写action对象在Spring工厂中的id（name）。

当使用注解式开发时

  1. 不要忘了在配置文件中加入<context:component-scan base-package="com.baizhi"/>

  2. 不要忘了在配置文件中加入<tx:annotation-driven transaction-manager="transactionManager"/>，同时，不用再配置事务属性和配置事务切面。

  3. 所有service实现类上都使用@Service注册自身到工厂；并使用@Transactional注解开启事务，同时，当前类中不是采用默认事务属性的service方法需要单独设置@Transactional的事务属性，比如查询类方法@Transactional(propagation = Propagation.SUPPORTS)等；其中使用到的所有dao都是成员属性，且使用@Autowired进行自动注入。例如：

    @Service
@Transactional
public class UserServiceImpl implements UserService{
    @Autowired
    private UserDao userDao;
    @Autowired
    private CityDao cityDao;

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

    @Override
    @Transactional(propagation = Propagation.SUPPORTS)
    public List<User> findAll() {
        return userDao.selectAll();
    }
}

  4. 所有action类上都使用@Controller注册自身到工厂;使用@Scope("prototype")声明为非单例；struts.xml中的class不要写全限定名而是写action对象在工厂中的id（name）；其中使用到的所有service都是成员属性，且使用@Autowired或@Resource进行自动注入。例如：

    @Controller
@Scope("prototype")
public class UserAction {
    @Autowired
    private UserService userService;
    @Autowired
    private CityService cityService;
}

    <package name="user" extends="struts-default" namespace="/user">
    <!--class为工厂中的id-->
    <!--使用@Controller注册的对象，默认id为类名首字母小写-->
    <action name="findAll" class="userAction" method="findAll">
        <result name="success">/index.jsp</result>
    </action>
</package>
万神.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spring+hibernate+struts2 +mybatis整合笔记
08-10
SSH开发笔记，特别适合入门者学习
Struts2&&SpringMVC
weixin_50485954的博客
03-17 224
Struts2 struts2在web应用层面属于表示层框架，在MVC开发模式中属于C（Controller控制器），负责对M（Model模型）和V（View视图）进行解耦。它本质上相当于一个servlet，在MVC设计模式中，Struts2作为控制器(Controller)来建立模型与视图的数据交互。 优点 实现了MVC模式，层次结构清晰提高了开发的效率。通过配置文件，可以掌握整个系统各个部分之间的关系。异常处理只需在配置文件中配置异常的映射，即可对异常做相应的处理，可扩展性高。 缺点 Struts2中A
Struts2注解
weixin_43721454的博客
03-16 249
注解 使用注解可以用来替换struts.xml配置文件，以提高我们的开发效率。 建议：注解的使用是建立在对struts.xml配置文件十分熟练的基础上。 注：单独使用struts2框架时注解，不需要配置注解扫描。 Struts2使用注解开发需要遵循一些规范 Action要必须继承ActionSupport父类 Action所在的包名必须以.action 结尾 引入依...
注解—Action（@Controller）
让我们的手指敲起锋利的代码勇敢前进！
12-21 2438
import org.apache.struts2.convention.annotation.Action; import org.apache.struts2.convention.annotation.ExceptionMapping; import org.apache.struts2.convention.annotation.ExceptionMappings; import o
struts2的核心和工作原理
热门推荐
蒋倩兰——蕙质兰心
05-30 38万+
在学习struts2之前，首先我们要明白使用struts2的目的是什么？它能给我们带来什么样的好处？ 设计目标     Struts设计的第一目标就是使MVC模式应用于web程序设计。在这儿MVC模式的好处就不在提了。 技术优势     Struts2有两方面的技术优势，一是所有的Struts2应用程序都是基于client/server HTTP交换协议，The Java Servlet
strut2执行流程介绍之init方法
went_java的专栏
04-21 582
最近突然对struts2的执行过程产生了兴趣。所以花了几个晚上看了看源码。将心得记录在这里。     本文是StrutsPrepareAndExecuteFileter中的init方法的介绍。时间有限，先写这些吧。有错误的地方希望有人能够批评指正 public void init(FilterConfig filterConfig) throws ServletException
SpringSSM框架整合完整框架.zip
08-02
SSM框架是Java web开发中常用的三..."SpringSSMKuangStudy"这个压缩包文件可能是某位开发者的学习笔记或者示例项目，下载后可以作为学习SSM框架的参考资料，通过查看和运行其中的代码，有助于深入理解SSM的整合与使用。
SSM 框架整合教程：二、Spring-尚硅谷学习笔记 2022 年
最新发布
09-08
本教程将深入探讨Spring框架的核心概念及其在SSM整合中的作用，结合尚硅谷2022年的学习笔记，为开发者提供一份详尽的指南。 **一、Spring框架简介** Spring是一款开源的Java平台，它提供了全面的企业级应用开发解决...
java基础笔记+前端+SSM框架
10-12
SSM框架笔记是指Spring、Struts和MyBatis这三大Java web开发框架的综合学习。Spring是一个全面的后端应用框架，提供了依赖注入（DI）和面向切面编程（AOP）等特性，以及对其他框架的集成支持，如数据访问、缓存、...
传智播客ssh+ssm五大框架笔记
04-24
传智播客的SSH+SSM五大框架笔记，虽然缺少了Struts2的最后一天教案，但依然能提供关于这五个框架的基础知识和整合实践。通过这些笔记，你可以了解每个框架的核心概念、配置方法以及它们如何协同工作。同时，建议配合...
SSM整合过程(配置文件版) Struts2+Spring+Mybatis
weixin_44972575的博客
12-19 311
@[TOC](SSM整合过程(配置文件版) Struts2+Spring+Mybatis) 一、SSM整合过程(配置文件版) Struts2+Spring+Mybatis 1.创建web项目 2.补全开发环境
ssm框架之struts2_day01
github_37217206的博客
02-27 514
一： struts2概述： JavaEE三大框架之一的web层框架，每次访问action的时候，都会创建一次，是线程安全的，内置拦截器，数据操作，值栈等 二： struts2解决问题：   三： 创建一个HellowWord程序： 1 ：导入jar包： 2  创建action： package cn.hr.action.demo; import com.opensymp...
详述lazy-init作用
飞翔的企鹅的博客
02-22 1112
一、lazy-init介绍 我们在使用Spring框架创建IoC容器时，ApplicationContext实现的默认行为会在启动时将所有singleton bean对象提前进行实例化，这会让ApplicationContext实例提前创建并配置所有的bean对象。这一点可以从下面“构造方法”的例子中证明： application.xml <bean id="userInfo" cl...
Java-struts2-quartz定时任务
qq_39957042的博客
10-29 1168
先创建一个applicationContext_timer.xml，具体内容如下： &amp;lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&amp;gt; &amp;lt;beans xmlns=&quot;http://www.springframework.org/schema/beans&quot; xmlns:xsi
struts2+quartz定时任务
cm777的博客
05-23 5707
最近有需求要写一个定时任务 目的是更新一些员工/人员与部门之间的关系 项目用的是struts2 当我加了spring的jar包之后写了一个定时任务 项目经理不让用spring 就修改一下 这次贴个全的 下面是任务类package com.timetask.action; import java.io.BufferedWriter; import java.io.File; import java....
MyBatis笔记
万神小栈
12-30 948
MyBatis 笔记 MyBatis 是基于 Java 语言的开源的持久层框架，利用实体类和数据表之间产生了关联，通过映射文件中的 sql 语句对数据库进行操作</p> <p>使用 maven 创建工程需要导入 <code>mybatis</code> 的依赖：</p> <pre><code>&lt;dependency&gt; ...
ssm 之 Struts 基础
qq_35328937的博客
08-01 266
第一步：导入Struts的支持包： 至少有十二个： 第二步：web.xml 主配置文件中的配置Struts 第三步：写一个action来接收页面提交的参数  和 发送到页面的参数  必须要有set和get方法（set获取值，get 传值） （获取值得名字必须与页面提交时的name一致不然获取不到值） 第四步：写Struts.xml文件： （act
SSM及spring与struts2区别
weixin_44178762的博客
12-30 1365
spring MVC  执行流程 用户请求前端控制器  前端控制器调用handlerMapp 处理器映射器  然后通过url找的 处理器适配器  处理器适配器调用后端处理器（controller）返回ModelandView  到前端控制器 前端控制器把ModelAndView传给视图解析器得到具体的View  前端控制器对view经行渲染视图 然后返回到用户 ioc (Inversion of...
注解和bean方法将dao对象作为引用类型属性创建ServiceImp对象
HSH541的博客
08-15 563
创建dao对象，（注解 或 bean，或调用框架的MapperScannerConfigurer类三种方法） 将dao对象作为StudentServiceImp类引用类型属性创建StudentServiceImpl对象（注解 或 bean两种方法) 需要做3件事： 创建dao对象（三种） 自动注入（注解，两种类型，放在service实现类中的dao对象上面），或set注入，或构造器注入（又是两种）共4种 创建ServiceImp对象（注解 或 bean两种方法) 所以可以产生24种以上的配对方法（自.
SSM框架整合详解：Spring+SpringMVC+MyBatis
"本文是关于SSM框架的整合教程，主要涵盖了Spring、SpringMVC和MyBatis三个组件的详细整合过程。" SSM框架整合是Java Web开发中常见的技术栈，它结合了Spring框架的核心功能，SpringMVC的 MVC 设计模式，以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

万神.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值