百木园-与人分享，
就是让自己快乐。
当前位置：百木园 > 野生技术 > 正文

SSM总结

2022-12-09 分类：野生技术 阅读(215) 评论(0)

SSM

目录

  • SSM
    • Spring
      • IOC（控制反转）& DI（依赖注入）
        • Bean注入方式
      • AOP（面向切面编程）
        • 一、AOP编程思想
          • 1.1 什么是AOP
          • 1.2 为什么需要AOP
          • 1.3 AOP实现方法分类
        • 二、AOP的专有名词
        • 三、认识SpringAOP
          • 3.1 SpringAOP的特点
          • 3.2 SpringAOP使用与实现
      • 代理模式
        • 静态代理
        • JDK动态代理
        • CGlib动态代理
    • SPring MVC
      • SpringMVC核心组件
      • SpringMVC第一个程序
      • 处理请求以及响应
        • 参数传递
        • 响应 页面跳转
      • SpringMVC基本配置
      • SpringMVC文件上传
      • Restful风格接口
      • SpringMVC工作流程
    • MyBAtis
      • 实现原理：工厂模式
        • 简单工厂
        • 工厂方法
        • 抽象工厂
      • MyBatis基本应用
        • MyBatis的基本配置(MyBatis-config.xml)
          • MyBatis数据源配置
            • 数据库连接池 （druid c3p0）
          • 映射文件配置
          • 其他配置
          • MyBatis整合Log4J
        • MyBatis主要构件
      • MyBatis映射文件
        • 基本标签
        • 动态SQL
        • ResultMap
          • 基础查询 - 基本映射
          • 外联查询 - 一对一查询
          • 外联查询 - 一对多查询
      • MyBatis 一级缓存与二级缓存
    • 事务管理
      • Spring事务管理
        • 事务的特性（ACID）
        • 事务的隔离级别
        • Spring事务
          • 编程式事务
          • 声明式事务
        • 事务传播机制

Spring

IOC（控制反转）& DI（依赖注入）

IOC是容器，用来装Spring创建的Bean对象。

Bean注入方式

  • Set方法注入
  • 构造器注入
  • @Autowared自动注入
<!--     SpringBean的注入方式  -->
<!--      手动装配  -->
<!--      ==  set方法注入    -->
    <bean id=\"hello\" class=\"com.dzqc.smbms.entity.SUser\">
        <property name=\"userCode\" value=\"hello\"></property>
        <property name=\"userName\" value=\"Spring\"></property>
        <property name=\"role\">
            <bean class=\"com.dzqc.smbms.entity.SRole\">
                <property name=\"roleCode\" value=\"这里是注入的实例对象\"></property>
                <property name=\"roleName\" value=\"这里是注入的实例对象的值\"></property>
            </bean>
        </property>
        <property name=\"role\" ref=\"myRole\"></property>
    </bean>

    <bean name=\"myRole\" class=\"com.dzqc.smbms.entity.SRole\">
        <property name=\"roleName\" value=\"管理员\"></property>
        <property name=\"roleCode\" value=\"SMBMS_ADMIN\"></property>
    </bean>

<!--      ==  带参构造器注入  -->
    <bean name=\"constructor\" class=\"com.dzqc.smbms.entity.SUser\">
        <constructor-arg name=\"userName\" value=\"这是通过构造器注入的userName\"></constructor-arg>
        <constructor-arg name=\"userCode\" value=\"这是通过构造器注入的userCode\"></constructor-arg>
    </bean>

    <!--  自动装配  -->
    <!--  ==  配置包扫描，并使用注解进行注入  -->
    <context:component-scan base-package=\"com.dzqc.smbms\">
        <context:exclude-filter type=\"annotation\" expression=\"org.springframework.stereotype.Controller\"/>
    </context:component-scan>

IOC和DI的区别：

IOC是什么：是控制反转，将new对象的权力由调用程序交给第三方IOC容器，控制权被转移给了IOC容器，在调用程序看来，new对象的动作由主动变成了被动，所以叫做控制反转。

DI是什么：依赖注入，将IOC容器中new出来的对象注入进调用程序。

IOC和ID的区别：IOC和DI是一体的，DI是IOC的另一种表现形式，是同一事件不同层面的解读。

AOP（面向切面编程）

一、AOP编程思想

1.1 什么是AOP

​ AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP是一种编程思想，基于面向对象编程思想（OOP）的补充。面向对象编程将程序抽象成了各个切面。

1.2 为什么需要AOP

​ 在开发过程中，存在某段多次重复的代码，以面向过程编程方式的话，我们会将这段代码抽象成一个方法，在需要的位置调用该方法。当这段代码需要修改时，我们就只需要改变这一个方法就够了。

​ 但需求不是一成不变的，如果后期需要新增一个需求，又需要在多处进行修改，就需要再抽象一个方法，然后在需要的位置再分别调用这个方法。又或者，我们在业务过程中删除这个方法，我们就需要删除掉每一个地方的调用。

​ 在这种情况之下，我们就可以通过使用AOP来解决。

1.3 AOP实现方法分类

​ 首先我们要知道AOP的目的，AOP要达到在开发者不修改源代码的前提下，去为系统中的业务添加某种通用的功能。

​ AOP的实现方式大致可以分为两类：

  • 静态AOP实现
    • 静态AOP实现是在编译阶段就对程序源代码进行修改，生成了静态的AOP代理类，即生成的*.class文件已经被修改，需要使用特定的编译方式进行编译。代表性的静态AOP实现方式如：AspectJ
  • 动态AOP实现
    • AOP框架在运行阶段动态生成代理对象。即在内存中以JDK动态代理的方式，或CGlib动态生成AOP代理类，典型的技术如：SpringAOP。
类别 机制 原理
静态AOP 静态织入 在编译前，切面直接以字节码的形式编译入目标代码的字节码文件中，对性能无影响，但灵活性不够。
动态AOP JDK动态代理 在运行期间，目标类加载之后为接口动态生成代理类，将切面织入到代理类中，相对于静态AOP更灵活一些。但切入点需要实现接口，对系统的性能有一定影响。
动态字节码生成 CGlib 在运行期间，目标类加载之后，动态生成目标类的子类，然后将切面的逻辑加入到子类中，相对于JDK动态代理的方式，CGlib不需要接口也可以实现织入，但是当扩展类的实例方法使用final修饰时无法进行织入。

二、AOP的专有名词

AOP中的特性术语大致有一下几种：

  • 增强|建议(Advice)：AOP框架中的增强处理，通知表述了切面在何时执行以及如何执行增强处理。
  • 连接点(join point) ：连切点表示应用程序执行过程中能够插入切面的一个点，这个点可以是方法的调用、异常的抛出。在SpringAOP中，连接点总是方法的调用。
  • 切点(PointCut)：可以插入增强处理的连接点。
  • 切面(Aspect)：切面是增强和切点的结合。
  • 引入(Introduction)：引入允许我们想现有的类添加新的方法或属性。
  • 织入(Weaving)：将增强处理添加到目标对象中，并创建一个被增强对象，这个过程就是织入。
  • 目标对象(Target)：增强的目标对象，原始对象。
  • 代理对象(Proxy)：加入了增强的对象，是由AOP增强后生成的代理对象。

SpringAOP在AOP的基础上又多出几个延伸概念：

  • 前置增强(MethodBeforeAdvice)：在连接点执行前进行增强。
  • 环绕增强(MethodInterceptor)：在连接点前后都执行增强。
  • 异常增强(ThrowsAdvice)：连接点抛出异常时进行增强。
  • 返回值增强(AfterReturingAdvice)：连接点产生返回值后进行增强。

三、认识SpringAOP

3.1 SpringAOP的特点

​ AOP的框架有很多，实现方式各不相同，Spring的AOP则是通过动态代理进行实现的。下面简单对代理模式进行介绍。

3.2 SpringAOP使用与实现
  • Spring原生API：实现 MethodBeforeAdvice接口、AfterReturningAdvice接口，重写对应的方法，并配置增强类与切入点类，可以实现AOP操作。
  • 自定义切面类：自定义切面类与增强方法，使用配置声明切面类并关联切点，实现AOP
  • 注解实现AOP：使用@Aspect声明切面类，@Pointcut声明切入点，使用@Before@After....注解实现增强方法，并配置自动代理，来实现AOP。

Execution表达式：

​ 声明具体方法的位置的表达式 ：返回值 包路径.类名.方法名(参数列表)

代理模式

​ 代理模式分为两种：

  • 静态代理：需要为每个角色创建对应的代理对象。
  • 动态代理：自动为每个目标角色生成对应的代理对象。

静态代理

​ 被代理类接口：

package com.dzqc.smbms.proxy;

/**
 * 游戏接口
 */
public interface Game {

    public void gameStart();

    public void gameOver();
}

被代理类：

package com.dzqc.smbms.proxy;

public class Mario implements Game{

    @Override
    public void gameStart() {
        System.out.println(\"超级马里奥，游戏开始！\");
    }

    @Override
    public void gameOver() {
        System.out.println(\"够不着旗杆，游戏结束\");
    }
}

代理类：

package com.dzqc.smbms.proxy;

/**
 * 本类为 静态代理 类
 * 代理类 需要 持有 目标对象
 */
public class GameStaticProxy implements Game{
    private Game targetGame;

    public Game getProxy(Game targetGame){
        this.targetGame = targetGame;
        return this;
    }
    @Override
    public void gameStart() {
        System.out.println(\"游戏机启动\");
        System.out.println(\"游戏启动！\");
        targetGame.gameStart();
        System.out.println(\"游戏进行中，mario他跳起来了\");
    }
    @Override
    public void gameOver() {
        System.out.println(\"mario 打败了魔王，找到了旗杆，要爬旗杆。 \");
        targetGame.gameOver();
        System.out.println(\"真菜，不玩了，破游戏什么时候关服！\");
    }
}

测试类：

package com.dzqc.smbms.proxy;

import org.junit.Test;

import java.lang.reflect.Proxy;

public class ProxyTest {

    @Test
    public void staticProxy(){
        Mario mario = new Mario();
        GameStaticProxy gameStaticProxy = new GameStaticProxy();
        Game marioProxy = gameStaticProxy.getProxy(mario);

        marioProxy.gameStart();

        marioProxy.gameOver();

    }
}

测试结果：

游戏机启动
游戏启动！
超级马里奥，游戏开始！						//原始内容
游戏进行中，mario他跳起来了
mario 打败了魔王，找到了旗杆，要爬旗杆。 
够不着旗杆，游戏结束						 //原始内容
真菜，不玩了，破游戏什么时候关服！

JDK动态代理

​ JDK动态代理的实现逻辑大致如下：

接口与被代理类与上述一致。

代理类：

package com.dzqc.smbms.proxy;

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

/**
 * JDK代理类
 */
public class GameJDKProxy implements InvocationHandler {

    private Game targetGame;
    public GameJDKProxy(Game targetGame){
        this.targetGame = targetGame;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String name = method.getName();

        if (name.equals(\"gameStart\")){
            Object o = gameStart(method, args);
        }else {
            Object o = gameOver(method, args);
        }
        return null;
    }
    private Object gameStart(Method method , Object[] args) throws Throwable{
        System.out.println(\"mario游戏启动了\");
        Object invoke = method.invoke(targetGame, args);
        System.out.println(\"正在操作mario通水管\");
        return null;
    }
    private Object gameOver(Method method , Object[] args) throws Throwable{
        System.out.println(\"水管打不通\");
        Object invoke = method.invoke(targetGame, args);
        System.out.println(\"什么破游戏！\");
        return null;
    }

}

测试类：

package com.dzqc.smbms.proxy;

import org.junit.Test;

import java.lang.reflect.Proxy;

public class ProxyTest {
    @Test
    public void jdkProxy(){
        Mario mario = new Mario();
        GameJDKProxy gameJDKProxy = new GameJDKProxy(mario);
//        使用JDK动态代理类获取代理对象
        Game marioProxy  = (Game) Proxy.newProxyInstance(
                this.getClass().getClassLoader(), //类加载器
                new Class[]{Game.class},  // 代理接口的字节码文件
                gameJDKProxy// 自己的代理类，进行目标方法扩充
        );
        marioProxy.gameStart();
        marioProxy.gameOver();
    }
}

测试结果

mario游戏启动了
超级马里奥，游戏开始！				//原始内容
正在操作mario通水管
水管打不通
够不着旗杆，游戏结束				 //原始内容
什么破游戏！

​ 由上述代码不难看出，动态代理的实现需要以下几点：

  1. JDK动态代理需要声明接口。想要创建一个动态代理类，就必须给这个类声明一个接口，否则无法在Proxy.newProxyInstance时传入对应的接口类字节码文件。
  2. 在代理类中需要通过构造传入原有的bean，因为处理完附加功能外，需要执行原有bean中的方法，以实现代理的目的。

CGlib动态代理

代理类：

package com.dzqc.smbms.proxy;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class GameCglibProxy implements MethodInterceptor {

    private Game targetGame;
    public GameCglibProxy(Game targetGame){
        this.targetGame = targetGame;
    }

    /**
     * 获取代理对象
     * @return
     */
    public Game getProxy(){
//        获取cglib操作类
        Enhancer enhancer = new Enhancer();
//        指定代理类 的 父类类型，要代理哪个类就使用哪个类做代理类的父类
        enhancer.setSuperclass(Mario.class);
//        指定代理对象，把当前代理类作为代理对象
        enhancer.setCallback(this);
//        创建并返回代理对象
        return (Game) enhancer.create();
    }

    /**
     * 代理增强的实际操作处
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        String name = method.getName();
        if (name.equals(\"gameStart\")){
            gameStart(method , objects);
        }else {
            gameOver(method , objects);
        }
        return null;
    }

    private Object gameStart(Method method , Object[] args) throws Throwable{
        System.out.println(\"魂斗罗启动！！！！\");
        Object invoke = method.invoke(targetGame, args);
        System.out.println(\"正在操作Mario和魂斗罗兄弟决斗\");
        return null;
    }
    private Object gameOver(Method method , Object[] args) throws Throwable{
        System.out.println(\"Mario挖了下水道，坑了魂斗罗兄弟\");
        Object invoke = method.invoke(targetGame, args);
        System.out.println(\"不要串台！\");
        return null;
    }

}

测试类：

package com.dzqc.smbms.proxy;

import org.junit.Test;

import java.lang.reflect.Proxy;

public class ProxyTest {
    @Test
    public void cglibProxy(){
        Mario mario = new Mario();
        GameCglibProxy gameCglibProxy = new GameCglibProxy(mario);
        Game proxy = gameCglibProxy.getProxy();
        proxy.gameStart();
        proxy.gameOver();
    }
}

测试结果：

魂斗罗启动！！！！
超级马里奥，游戏开始！					//原始内容
正在操作Mario和魂斗罗兄弟决斗
Mario挖了下水道，坑了魂斗罗兄弟
够不着旗杆，游戏结束					 //原始内容
不要串台！

​ 由上述代码不难看出，CGlib在进行动态代理的过程中，对被实现的类要求较少，而且更为灵活，使用者可以根据实际情况进行选择。

SPring MVC

MVC是什么？MVC是设计模式，包含Model（模型）、View（视图）、Controller（控制器）。

SpringMVC就是基于MVC设计模式创建的一个控制层框架，用来简化视图与后台的数据交互工作，并且规范开发方式。SpringMVC是对Servlet的封装，可将SpringMVC的本质看作Servlet。

SpringMVC核心组件

  • 前端控制器|中央处理器（DispatcherServlet）：用来调度整个MVC的请求走向。
  • 处理器适配器（HandlerAdapter）：用来适配请求路径对应的处理器
  • 处理器映射器（HandlerMapping）：用来查找请求路径对应的处理器方法
  • 处理器（Controller | Handler）：处理请求的方法
  • 视图解析器（ViewResolver）：解析视图、返回路径、请求转发与响应的解析器
  • 视图（View）：页面
  • 拦截器（Interceptor）：拦截请求

SpringMVC第一个程序

处理请求以及响应

参数传递

类需要使用@Controller注解，在类中声明一个Handler方法，在方法的参数列表中声明需要的参数，在Handler方法被调用时，就可以正确传入对应的参数。

  • 常用简单数据类型：String，Integer，Char，Boolean，Byte，Short，Long，Float，Double。
  • 复杂数据类型：
    • 对象：对象在进行参数传递时，参数列表中声明的为对象，在传参的过程中，传递的是对象中声明的属性名。
    • 数组：数组在进行传参时，数组的参数名需要多次出现，每次出现给数组赋一个 值。
      • http://localhost:9999/ssm/arr?arr=name1&arr=name2&arr=name3
    • List集合：在进行参数传递时，因为List集合是个接口，所以需要在List类型的参数前加上@RequestParam注解，在参数传递时，与数组传参方式一致。
    • map集合：在进行参数传递时，需要加上@RequestParam注解，参数在拼接时，只需将key和value的值按照普通传参的方式拼接在地址栏或参数列表中。

响应 页面跳转

  1. 只响应数据：数据接口，在Handler方法上需要添加@ResponseBody注解，添加完成后，返回值不会被视图解析器进行解析，在返回时可以按照正常的数据进行返回。
  2. 默认页面返回：默认的响应方式，本质上是请求转发，在Handler方法进行return后，会将返回的数据转发至DispatcherServlet，然后由DispatcherServlet调度视图解析器，解析返回值中的数据与视图并响应。
  3. 重定向：重定向可以重定向到任意路径，只需要在返回值上、ModelAndView的视图名前 加上 redirect，这里的重定向与Servlet的重定向功能保持一致，流程有变动。在Handler（处理器）方法进行返回后，将请求转发至DispatcherServlet（中央处理器），由DispatcherServlet（中央处理器）调度HttpServletResponse（响应），由HttpServletResponse（响应）进行重定向操作。

SpringMVC基本配置

在web.xml种配置 dispatcherServlet

  <!--  配置中央处理器，与Servlet一起初始化  -->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath*:spring-mvc.xml</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>



  <!--  配置SpringIOC容器  -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>

在Spring文件当中配置

<?xml version=\"1.0\" encoding=\"UTF-8\"?>
<beans xmlns=\"http://www.springframework.org/schema/beans\"
       xmlns:context=\"http://www.springframework.org/schema/context\"
       xmlns:mvc=\"http://www.springframework.org/schema/mvc\"
       xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"
       xsi:schemaLocation=\"
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd
\">
    <!--  配置包扫描,扫描所有使用Controller注解的类  -->
    <context:component-scan base-package=\"com.dzqc.smbms\">
        <context:include-filter type=\"annotation\" expression=\"org.springframework.stereotype.Controller\"/>
    </context:component-scan>
    

    <!--  处理器适配器  -->
    <bean name=\"handlerAdapter\"
          class=\"org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter\"></bean>

    <!--  处理器映射器  -->
    <bean name=\"handlerMapping\"
          class=\"org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping\"></bean>


    <!--  视图解析器  -->
    <bean name=\"viewResolver\"
          class=\"org.springframework.web.servlet.view.InternalResourceViewResolver\">
        <property name=\"prefix\" value=\"/views/\"></property>
        <property name=\"suffix\" value=\".jsp\"></property>
    </bean>

    <!--  配置静态资源过滤器  -->
    <mvc:default-servlet-handler/>
    <mvc:resources location=\"/statics/\" mapping=\"/static/*\"></mvc:resources>


    <!--  文件上传解析器  -->
    <bean name=\"multipartResolver\"
          class=\"org.springframework.web.multipart.commons.CommonsMultipartResolver\">
        <!--  最大支持文件大小，此处配置50MB大小限制  -->
        <property name=\"maxUploadSize\" value=\"52428800\"></property>
    </bean>
</beans>

SpringMVC文件上传

依赖：

<!--  文件上传  -->
<dependency>
  <groupId>commons-fileupload</groupId>
  <artifactId>commons-fileupload</artifactId>
  <version>1.4</version>
</dependency>

Restful风格接口

Rest注解：

  • @RestController
  • @GetMapping
  • @PostMapping
  • @PutMapping
  • @DeleteMapping
  • @PathVariable

SpringMVC工作流程

准备工作：

/*  在SpringMVC首次刷新或重新加载时，会调用SpringMVC初始化策略  */
protected void onRefresh(ApplicationContext context) {
    this.initStrategies(context);
}
/**  初始化策略方法  */
protected void initStrategies(ApplicationContext context) {
    this.initMultipartResolver(context);       		// 初始化文件上传解析器
    this.initLocaleResolver(context); 	 			// 初始化本地解析器
    this.initThemeResolver(context);	 			// 初始化中心解析器
    this.initHandlerMappings(context);   			// 初始化处理器映射器
    this.initHandlerAdapters(context);   			// 初始化处理器适配器
    this.initHandlerExceptionResolvers(context);    // 初始化处理器异常解析器
    this.initRequestToViewNameTranslator(context);  // 初始化 请求视图 翻译器
    this.initViewResolvers(context);				// 初始化视图解析器
    this.initFlashMapManager(context);				// 初始化 映射刷新管理器
}

2：请求处理流程

  1. DispathcerServlet（前端控制器）接收请求 ：DispatcherServlet 通过 doService()方法 接收用户请求。调用 doDispatch() 方法进行请求调度。
  2. DispatcherServlet（前端控制器）调用HandlerMapping（处理器映射器）：DispatcherServlet 通过getHandler() 调用HandlerMapping获取HandlerExecutionChain
  3. HandlerMapping将（HandlerExecutionChain）处理器执行链返回给DispatcherServlet
  4. DispathcerServlet(前端控制器)通过HandlerAdapter(处理器适配器)，获取对应的Handler处理器方法。
  5. HandlerAdapter(处理器适配器)调用Handler处理器方法，处理用户请求。
  6. Handler处理器方法将返回值返回给HandlerAdapter（处理器适配器）
  7. HandlerAdapter将Handler处理器方法的返回值以ModelAndView的形式返回给DispatherServlet：
  8. DispatcherServlet将ModelAndView交给ViewResolver（视图解析器）解析。
  9. ViewResolver(视图解析器)将ModelAndView中的数据渲染到View(视图)中。
  10. ViewResolver返回的视图信息到DispatcherServlet。
  11. DispatcherServlet将视图信息及返回值返回给客户端。

image-20221204094023826

MyBAtis

​ MyBatis是一款轻量级的ORM（对象关系映射）（持久化）框架，能够将JDBC相关的持久化代码通过配置文件的形式实现，提高开发效率。

实现原理：工厂模式

手机工厂：MI，IPHONE，HUAWEI

简单工厂

工厂对象：

抽象实体：

具体实体：

工厂方法

抽象工厂：

抽象产品：

实体工厂：

实体产品：

抽象工厂

MyBatis基本应用

MyBatis使用分为

  • 配置文件（mybatis-config.xml）
  • mapper接口
  • 与mapper接口对应的mapper.xml映射文件

MyBatis的基本配置(MyBatis-config.xml)

MyBatis数据源配置
<!--  环境配置标签 default中引用的为默认使用的环境  -->
<environments default=\"development\">
    <!--  环境标签 id 唯一，不可重复  -->
    <environment id=\"development\">
        <!--  事务管理器配置  -->
        <transactionManager type=\"JDBC\"/>
        <!--  数据源配置 type默认为POOLED（默认启用数据库连接池模式） ，UNPOOLED 不启用连接池  -->
        <dataSource type=\"POOLED\">
            <!--  属性标签，该处属性为数据源配置属性  -->
            <property name=\"driver\" value=\"com.mysql.cj.jdbc.Driver\"/>
            <property name=\"url\" value=\"jdbc:mysql://localhost:3306/smbms_3\"/>
            <property name=\"username\" value=\"root\"/>
            <property name=\"password\" value=\"root\"/>
        </dataSource>
    </environment>
</environments>
数据库连接池 （druid c3p0）
映射文件配置
<mappers>
    <!--  映射文件的地址，引用相对路径  -->
    <mapper resource=\"mappers/SUserMapper.xml\"></mapper>
</mappers>
其他配置
    <!--  MyBatis别名配置 只能配置实体类  -->
    <typeAliases>
<!--        <typeAlias type=\"com.dzqc.smbms.entity.SUser\" alias=\"u\"></typeAlias>-->
        <package name=\"com.dzqc.smbms.entity\"/>
    </typeAliases>

    <settings>
        <!--  配置控制台日志组件  -->
        <setting name=\"logImpl\" value=\"STDOUT_LOGGING\"/>
    </settings>
MyBatis整合Log4J

MyBatis主要构件

获取资源：Resources.getResourceAsStream(\"MyBatis-config.xml\");

SqlSessionFactoryBuilder：构建工厂的建筑队，需要给资源后，调用build方法才能构建工厂。

SqlSessionFactory：工厂建好后，调用openSession方法，产出SqlSession

SqlSession：产出的SqlSession可以通过Mapper接口的字节码（.class）来获取SqlSession中生产的代理对象，从而操作数据库。

MyBatis映射文件

基本标签

<select id=\"唯一，不可重复\" parameterType=\"参数类型\" resultType=\"返回值类型\" resultMap=\"\"
        >查询SQL</select>


<insert id=\"唯一，不可重复\" parameterType=\"\" keyColumn=\"\" keyProperty=\"\" useGeneritedKeys=\"true\">插入语句</insert>

<update id=\"唯一，不可重复\" parameterType=\"\" >修改语句</update>

<delete id=\"唯一，不可重复\" parameterType=\"\" >删除语句</delete>

动态SQL

  • 判断条件成立时，会向SQL后拼接的条件语句
  • 自动判断，如果where中包含的有任意一个或多个成立，就会自动向SQL后拼接 where ， 并将中的拼接语句之前的关键字进行适当的截取。
  • ：拼接SQL的动态字段，常用属性有 perfix ， suffix ， perfixOverrides，suffixOverrides。
  • ：自动拼接Set关键字，并截取中的后缀内容。
  • ：column：要遍历的循环体内容，item：每次循环到的元素，open：开始时自动拼接的内容，close：结束时自动拼接的内容，seprector：分隔符，自动在每个元素后面拼接的内容。

ResultMap

resultMap是MyBatis实现ORM特性的一个最重要的标签。

基础查询 - 基本映射

代表主键列 ：column - 数据库列名 ， property：实体类属性名

普通列 ：column - 数据库列名 ， property：实体类属性名

外联查询 - 一对一查询
<association property=\"role\" javaType=\"srole\" column=\"u.userRole\">
    <id column=\"userRole\" property=\"id\"></id>
    <result column=\"roleCode\" property=\"roleCode\"></result>
    <result column=\"roleName\" property=\"roleName\"></result>
</association>

<association property=\"role\" javaType=\"srole\" column=\"userRole\"
            select=\"com.dzqc.smbms.mapper.SRoleMapper.selectById\" >
</association>

property：实体类的属性名

column：外关联字段的字段名

javaType：property对应的实体类的类型。

select：外关联查询的方法

外联查询 - 一对多查询
<collection property=\"roleUsers\" column=\"id\" javaType=\"list\" ofType=\"suser\"
            select=\"com.dzqc.smbms.mapper.ISUserMapper.selectByRoleId\">
</collection>

property：实体类的属性名

column：外关联字段的字段名

javaType：一对多关联集合类型。

ofType：一对多关联集合中存放的数据的类型。

select：外关联查询的方法

MyBatis 一级缓存与二级缓存

事务管理

Spring事务管理

什么是事务：事务的本身其实就是一组业务逻辑，在业务逻辑当中包含有针对于数据库持久化的操作。在事务当中的所有业务逻辑被视为一个整体。

事务的特性（ACID）

  • 原子性（Atomicity）：事务中所有的操作，被视为一个整体，一组业务逻辑中一旦有一点出现异常或失败，那么所有的业务逻辑都被视为失败。原子性保证了事务当中的业务逻辑要么全部成功，要么全部失败。
  • 一致性（Consistency）：事务的操作，不能破坏数据库中的数据完整性，在事务执行之前或执行之后，数据库都处于一致的状态。在事务中一旦对数据进行持久化，那么持久化的数据一定符合该数据库的所有规范，不会破坏数据库中数据的完整性。
  • 持久性（Durability）：事务中的数据一旦被提交，在之后的操作中都可以查询到，无论出现什么故障都不会导致数据的损坏或丢失（物理损坏除外，存储介质损坏）。
  • 隔离性（Isolation）：数据库允许多个事务同时执行，事务之间的数据相互不会有影响。

事务的隔离级别

事务不隔离会产生的问题：

脏读：当前事务读到了其他事务未提交的数据

幻读（虚读）：当前事务重复读取同样的数据，读取到了其他事务新增的数据，导致短时间内两次读取的数据不一致。

不可重复读：当前事务读到了其他事务已提交的数据，在短时间，两次查询的结果不一致。

  • 读未提交(read-uncommitted)：默认隔离级别，允许当前事务读取其他事务未提交的数据，在该隔离级别中，脏读、幻读、不可重复读都有可能出现。
  • 读已提交(read-committed)：允许当前事务读取其他事务已提交的数据，在该隔离级别下，脏读不会出现，幻读和不可重复读有可能出现。
  • 可重复读(Repeatable-read)：允许当前数据读取其他事务新增的数据，不读取其他事务提交的修改数据（不允许修改操作）。在该事务隔离级别下，脏读与不可重复读不会出现，幻读有可能会出现。
  • 串行化(Serializable)：最高的事务隔离级别，脏读、幻读、不可重复读都不会出现，但是运行效率低，一般不使用。

Spring事务

编程式事务

优点：对事务的操作精细，能够更加精确的对事务进行管理

缺点：对代码的侵入度高，在后期进行维护、功能变更时会提高维护难度。

声明式事务

事务传播机制

事务传播机制一共有7种。

  1. requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，(事务默认传播机制)。
  2. supports：支持当前事务，如果没有当前事务，就以非事务方法执行。
  3. mandatory：使用当前事务，如果没有当前事务，就抛出异常。
  4. required_new：新建事务，如果当前存在事务，把当前事务挂起。
  5. not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
  6. never：以非事务方式执行操作，如果当前事务存在则抛出异常。
  7. nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作

来源：https://www.cnblogs.com/ATRIQAQ/p/16967996.html
本站部分图文来源于网络，如有侵权请联系删除。

未经允许不得转载：百木园 » SSM总结
标签：

相关推荐

  • 暂无文章

热门文章