Spring框架+SPringleMVC-狂神版整理

白日梦想家24

已于 2022-10-28 09:03:16 修改

阅读量342

点赞数 1

分类专栏：笔记文章标签： spring java 面试

于 2022-09-16 10:00:09 首次发布

本文链接：https://blog.csdn.net/weixin_47994925/article/details/126738907

版权

笔记专栏收录该内容

5 篇文章 0 订阅

订阅专栏

狂神笔记链接：ssm笔记

1.Spring

1.1 简介

Spring理念 : 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术

官网 : http://spring.io/

官方下载地址 :
https://repo.spring.io/libs-release-local/org/springframework/spring/

GitHub : https://github.com/spring-projects

1.2 优点

1、Spring是一个开源免费的框架 , 容器 .

2、Spring是一个轻量级的框架 , 非侵入式的 .

3、控制反转 IoC , 面向切面 Aop

4、对事物的支持 , 对框架的支持

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。

2.IOC（控制反转）

2.1 IOC原理

之前，程序是主动创建对象，控制权再程序员手上！
使用了set注入后，程序不再有主动性，而是变成了被动的接收对象！

这种思想，从本质上解决了问题，我们程序猿不用再去管理对象的创建了。系统的耦合性大大降低~，可以更加专注的在业务的实现上!这是IOC的原型!

2.2 IOC本质

控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

3.spring应用

3.1 搭建spring

1.导入jar包

<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>5.1.10.RELEASE</version>
</dependency>

2.编写一个Hello实体类

注意：Hello类中必须有set方法

public class Hello {
   private String name;

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

   public void show(){
       System.out.println("Hello,"+ name );
  }
}

3.编写我们的spring文件 , 这里我们命名为beans.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">

   <!--bean就是java对象 , 由Spring创建和管理-->
   <!--
   Hello hello = new Hello();
   id = 变量名
   class = new 的对象
   name = 类中属性名
   value ：给属性赋值，具体值，基本数据类型
   ref:引用Spring容器中创建好的对象
   **通过name里的类的参数类型判断 用value还是ref**
   -->
   <bean id="hello" class="com.kuang.pojo.Hello">
       <property name="name" value="Spring"/>
   </bean>

</beans>

4.测试

@Test
public void test(){
   //解析beans.xml文件 , 生成管理相应的Bean对象
   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
   //getBean : 参数即为spring配置文件中bean的id .
   Hello hello = (Hello) context.getBean("hello");
   hello.show();
}

5.思考

Hello 对象是谁创建的 ? hello 对象是由Spring创建的
Hello 对象的属性是怎么设置的 ? hello对象的属性是由Spring容器设置的

3.2 控制反转

这个过程就叫控制反转 :

控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的

反转 : 程序本身不创建对象 , 而变成被动的接收对象 .

依赖注入 : 就是利用set方法来进行注入的.

IOC是一种编程思想，由主动的编程变成被动的接收

4. IOC创建对象的方式

1.默认无参构造器创建对象

此时不能有有参构造器

无参构造器中.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">

   <bean id="user" class="com.kuang.pojo.User">
       <property name="name" value="kuangshen"/>
       <!--给对象属性赋值，利用set()方法，可以不赋值，则默认使用构造器赋值-->
   </bean>

</beans>

2.有参构造器创建对象

三种方式

有参构造器中，必须有constructor-arg 属性来初始化构造器参数，推荐使用第二种方式

结论

结论：在配置文件加载的时候。容器中管理的bean对象都已经初始化了！
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
这步指令执行完就已经对所有bean对象进行初始化了，并且<bean>中若有<property> 进行set赋值操作，也在该指令中完成了显式赋值

5.Spring的配置

5.1别名

alias 设置别名 , 为bean设置别名 , 可以设置多个别名

<alias name="userT" alias="userNew"/>

5.2 Bean的配置

<!--bean就是java对象,由Spring创建和管理-->

<!--
  id : bean的唯一标识符，也就是相当于我们学的对象名
  class : bean对象所对应的全限定名﹔包名＋类型
  name :也是别名,而且name可以同时取多个别名
   name可以设置多个别名,可以用逗号,分号,空格隔开
   如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;
-->
<bean id="hello" name="hello2 h2,h3;h4" class="com.kuang.pojo.Hello">
   <property name="name" value="Spring"/>
</bean>

5.3 import

这个import，一般用于团队开发使用，他可以将多个配置文件，导入合并为一个
假设，现在项目中有多个人开发，这三个人复制不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的!

applicationContext.xml

<import resource="beans1.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>

6. 依赖注入

概念：
依赖注入（Dependency Injection,DI）。
依赖 : 指Bean对象的创建依赖于容器 . Bean对象的依赖资源 .
注入 : bean对象中的所有属性，由容器来注入！

6.1 构造器注入

有参构造器：

<bean id="user" class="com.yang.pojo.User">
        <constructor-arg name="name" value="cxy"/>
        <constructor-arg name="id" value="02"/>
    </bean>

6.2 set方式注入【重点】

要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 ,
没有set方法 , 是 is

 <bean id="address" class="com.kuang.pojo.Address">
 		<!--内置bean        -->
        <property name="address" value="西安"/>
    </bean>

    <bean id="student" class="com.kuang.pojo.Student">
        <!--第一种：普通值注入，value        -->
        <property name="name" value="黑心白莲"/>

        <!--第二种： 内置bean注入       -->
        <property name="address" ref="address"/>

        <!--数组        -->
        <property name="books">
            <array>
                <value>红楼梦</value>
                <value>西游记</value>
                <value>水浒传</value>
                <value>三国演义</value>
            </array>
        </property>

        <!--List        -->
        <property name="hobbies">
            <list>
                <value>打篮球</value>
                <value>看电影</value>
                <value>敲代码</value>
            </list>
        </property>

        <!--Map        -->
        <property name="card">
            <map>
                <entry key="身份证" value="123456789987456321"/>
                <entry key="银行卡" value="359419496419481649"/>
            </map>
        </property>

        <!--Set        -->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>COC</value>
                <value>BOB</value>
            </set>
        </property>

        <!--NULL        -->
        <property name="wife">
            <null/>
        </property>

        <!--Properties        -->
        <property name="info">
            <props>
                <prop key="driver">20191029</prop>
                <prop key="url">127.0.0.1</prop>
                <prop key="user">root</prop>
                <prop key="password">123456</prop>
            </props>
        </property>

    </bean>

6.3 拓展方式注入

p命名和c命名注入

1.P命名空间注入 : 需要在头文件中加入约束文件

导入约束 : xmlns:p=“http://www.springframework.org/schema/p”

<!–P(属性: properties)命名空间 , 属性依然要设置set方法–>
<bean id="user"class=“com.kuang.pojo.User” p:name=“狂神” p:age=“18”/>

c 命名空间注入 : 需要在头文件中加入约束文件，必须有带参构造器

导入约束 : xmlns:c=“http://www.springframework.org/schema/c”
<!–C(构造: Constructor)命名空间 , 属性依然要设置set方法–>
<bean id=“user” class=“com.kuang.pojo.User” c:name=“狂神” c:age=“18”/>

6.4 bean的作用域

在Spring中，那些组成应用程序的主体及由Spring IoC容器所管理的对象，被称之为bean。简单地讲，bean就是由IoC容器初始化、装配及管理的对象 .

几种作用域中，request、session作用域仅在基于web的应用中使用（不必关心你所采用的是什么web应用框架），只能用在基于web的Spring ApplicationContext环境。

Singleton (默认下)
单例类型，在ClassPathXmlApplicationContext实例化的时候就完成了对配置文件中的bean对象的初始化，并且IOC容器中只有一个bean，不管你是否通过getBean()获得该对象，它都一致存在在容器内，每次获取到的对象都是同一个对象

 <bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">

Prototype
原型类型，当一个bean的作用域为Prototype，表示一个bean定义对应多个对象实例。在ClassPathXmlApplicationContext实例化时不会创建bean对象，容器内也不存在该bean对象，只有当每次调用getBean()方法时，才会创建一个新的bean实例。也就是说它在我们创建容器的时候并没有实例化，而是当我们获取bean的时候才会去创建一个对象，而且我们每次获取到的对象都不是同一个对象。

 <bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>

7. bean 的自动装配

在这里插入图片描述

7.1 byName自动装配

     <!--
        byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的bean id！
            -->
        <bean id="people" class="com.kuang.pojo.People" autowire="byName">
            <property name="name" value="小白莲"/>
        </bean>

7.2 ByType自动装配

 		<!--
        byType：会自动在容器上下文中查找，和自己对象属性类型相同的bean！
            -->
        <bean id="people" class="com.kuang.pojo.People" autowire="byType">
            <property name="name" value="小白莲"/>
        </bean>

小结：

ByName的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致！
ByType的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致！

7.3 使用注解实现自动装配

IOC配置文件中引入context文件头

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

开启属性注解支持
<context:annotation-config/>

@Autowired

直接在属性上使用
先按ByType自动装配，若无法匹配，再按ByName自动装配

public class User {
   @Autowired
   private Cat cat;
   @Autowired
   private Dog dog;
   private String str;

   public Cat getCat() {
       return cat;
  }
   public Dog getDog() {
       return dog;
  }
   public String getStr() {
       return str;
  }
}

@Qualifier

若@Autowired匹配不到，可以用@Qualifieri限定byName的方式自动装配

//在属性上添加Qualifier注解
@Autowired
@Qualifier(value = "cat2")
private Cat cat;
@Autowired
@Qualifier(value = "dog2")
private Dog dog;

由于dog的名字在配置文件中与dog1和dog2不匹配，并且多个同一类型情况下，通过类型也无法匹配，所以此时只能用@Qualifieri限定dog名字为dog2

<bean id="dog1" class="com.kuang.pojo.Dog"/>
<bean id="dog2" class="com.kuang.pojo.Dog"/>
<bean id="cat1" class="com.kuang.pojo.Cat"/>
<bean id="cat2" class="com.kuang.pojo.Cat"/>

@Resource

先进行byName查找，失败；再进行byType查找

8. 使用注解开发

首先要引入aop的包 --> 引入一个context约束 -->开启注解的支持 -->指定注解扫描包

配置扫描哪些包下的注解，下面的配置自动引入context约束
<context:component-scan base-package=“com.kuang.pojo”/>

1. bean的实现

在指定包下编写类，增加注解

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
   public String name = "秦疆";
}

2. 属性注入

可以不用提供set方法，直接在直接名上添加@value(“值”)

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
   @Value("秦疆")
   // 相当于配置文件中 <property name="name" value="秦疆"/>
   public String name;
}

3. 衍生注解

@Component三个衍生注解
为了更好的进行分层，Spring可以使用其它三个注解，功能一样，目前使用哪一个功能都一样。

@Controller：web层
@Service：service层
@Repository：dao层

4. 作用域:@scope

singleton：默认的，Spring会采用单例模式创建这个对象。关闭工厂，所有的对象都会销毁。
prototype：多例模式。关闭工厂，所有的对象不会销毁。内部的垃圾回收机制会回收

@Controller("user")
@Scope("prototype")
public class User {
   @Value("秦疆")
   public String name;
}

5. 总结

xml与注解整合开发：推荐最佳实践：

xml管理Bean
注解完成属性注入
使用过程中只需要注意：必须让注解生效，就需要开启注解的支持
~~<context:annotation-config/>~~ ：当使用<context:component-scan>后可以不声明<context:annotation-config/> ，<context:component-scan>中已经包含<context:annotation-config/>的功能

 <!--指定要扫描的包，这个包下的注解才会生效-->
  <!--开启注解的支持-->
    <context:component-scan base-package="com.yang"/>

9. AOP（Aspect Oriented Programming）

9.1 动态代理与静态代理

AOP的底层机制就是动态代理！
我们在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想

静态代理
在这里插入图片描述

动态代理
在这里插入图片描述

采用JDK动态代理实现AOP必须要使代理类和被代理类实现同一个接口。

public class ProxyFactory {
    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    public Object getProxy(){
        /**
         * ClassLoader loader：指定加载动态生成代理类的类加载器
         Class<?>[] interfaces：代理类的目标对象的所有接口
         InvocationHandler h ：代理类如何重写目标对象中的方法
         *
         */
        ClassLoader classLoader = this.getClass().getClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        InvocationHandler h = new InvocationHandler() { //匿名实现接口
            //proxy表示代理对象，method表示代理对象需要实现的方法，args方法中的参数列表
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Object result = null;
                try {
                    System.out.println("房东要出租房子");
                    //即目标对象中重写的方法，代理可以在目标对象执行的方法上下文进行其他操作，
                    // 目标只需要完成他自己的工作，剩下的代理帮他做
                    /**
                     *  Object result = method.invoke(target, args);
                     *  相当于
                     *  public void rent() {
                        System.out.println("客户租房子");
                        }
                     */
                    result = method.invoke(target, args);
                    System.out.println("带房东看房子");
                    System.out.println("签合同");
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }  finally {
                    System.out.println("方法执行完毕");
                }
                return result;
            }
        };

        Object proxy = Proxy.newProxyInstance(classLoader, interfaces, h);
        return proxy;
    }
}

动态代理的好处
静态代理有的它都有，静态代理没有的，它也有！

可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
公共的业务由代理来完成 . 实现了业务的分工
公共业务发生扩展时变得更加集中和方便 .
一个动态代理 , 一般代理某一类业务
一个动态代理可以代理多个类，代理的是接口！

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

在这里插入图片描述

在这里插入图片描述
使用AOP需要先导入一个依赖包

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
   <version>1.9.4</version>
</dependency>

9.2.1 第一种方式：通过 Spring API 实现

AOP基于动态代理，所以一定有业务接口，和其实现类即被代理类

在这里插入图片描述
然后去写我们的增强类 , 我们编写两个 , 一个前置增强一个后置增强

public class Log implements MethodBeforeAdvice {

   //method : 要执行的目标对象的方法
   //objects : 被调用的方法的参数
   //Object : 目标对象
   @Override
   public void before(Method method, Object[] objects, Object o) throws Throwable {
       System.out.println( o.getClass().getName() + "的" + method.getName() + "方法被执行了");
  }
}

public class AfterLog implements AfterReturningAdvice {
   //returnValue 返回值
   //method被调用的方法
   //args 被调用的方法的对象的参数
   //target 被调用的目标对象
   @Override
   public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
       System.out.println("执行了" + target.getClass().getName()
       +"的"+method.getName()+"方法,"
       +"返回值："+returnValue);
  }
}

最后去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">

   <!--注册bean-->
   <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
   <bean id="log" class="com.kuang.log.Log"/>
   <bean id="afterLog" class="com.kuang.log.AfterLog"/>

   <!--aop的配置-->
   <aop:config>
       <!--切入点 expression:表达式匹配要执行的方法-->
       <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
       <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
       <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
       <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
   </aop:config>

</beans>

aop:pointcut：设置切入点表达式
aop:advisor ：设置当前的一些通知
aop:aspect ：将某个组件设置为切面

测试：
注意，此时在IOC容器中即使有被代理类，但是使用了AOP后不能直接获得被代理类对象，并且AOP利用动态代理，创建一个代理类，我们并不知道代理类的名字，但是由于代理类和被代理类都实现同一接口，所以可以通过向上转型，获得接口的类型，即基于接口的动态代理

public class MyTest {
   @Test
   public void test(){
       ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
       UserService userService = (UserService) context.getBean("userService");
       userService.search();
  }
}

9.2.2 第二种方式 (实用)

自定义类来实现Aop
在这里插入图片描述
spring中配置

<!--第二种方式自定义实现-->
<!--注册bean-->
<bean id="diy" class="com.kuang.config.DiyPointcut"/>

<!--aop的配置-->
<aop:config>
   <!--第二种方式：使用AOP的标签实现-->
   <!--自定义切面，ref 要引用的类-->
   <aop:aspect ref="diy">
   		<!--切入点-->
       <aop:pointcut id="diyPonitcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
       <!--通知-->
       <aop:before pointcut-ref="diyPonitcut" method="before"/>
       <aop:after pointcut-ref="diyPonitcut" method="after"/>
   </aop:aspect>
</aop:config>

测试

public class MyTest {
   @Test
   public void test(){
       ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
       UserService userService = (UserService) context.getBean("userService");
       userService.add();
  }
}

9.2.3 第三种方式

使用注解实现

在这里插入图片描述
第二步：在Spring配置文件中，注册bean，并增加支持注解的配置

<!--第三种方式:注解实现-->
<bean id="annotationPointcut" class="com.kuang.config.AnnotationPointcut"/>
<aop:aspectj-autoproxy/>

若不想在xml配置文件中注册bean，也可以通过注解注册bean，此时需要引入

 <!--指定要扫描的包，这个包下的注解才会生效-->
    <context:component-scan base-package="com.yang"/>
    <!--开启注解的支持-->
    <context:annotation-config/>

10. Mybatis-spring

10.1 实现方式一

1.编写spring中注入mybatis的配置文件，最后IOC容器中获得SqlSessionTemplate类型的sqlSession，这样原来的mybatis的核心配置文件都可以利用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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--获得sessionFactory-->
   <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
       <property name="dataSource" ref="dataSource"/>
       <!--绑定mybatis配置文件-->
       <property name="configLocation" value="classpath:mybatis-config.xml"/>
       <property name="mapperLocations" value="classpath:com/yang/mapper/*.xml"/>
   </bean>

    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>
 	<!--获得sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sessionFactory"/>
    </bean>

</beans>

给接口编写实现类

public class UserMapperImpl implements UserMapper {

    //在原来我们的所有操作都用sqlSession执行，在现在，都是用sqlSessionTemplate
    private SqlSessionTemplate sqlSession;

    public UserMapperImpl(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    public List<User> select() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.select();
        return users;
    }
}

编写applicationContext.xml的spring配置文件，导入步骤1.中的spring配置文件，并将2.中实现类注入bean

<?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/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
 	<!--导入1.中的配置-->
   <import resource="spring-dao.xml"/> 

    <bean id="userMapperImpl" class="com.yang.mapper.UserMapperImpl">
        <constructor-arg name="sqlSession" ref="sqlSession"/>
    </bean>
</beans>

4.测试使用

@Test
    public void select()  {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapperImpl", UserMapper.class);
        List<User> users = userMapper.select();
        for (User user : users) {
            System.out.println(user);
        }
    }

10.2 实现方式二

dao继承Support类 , 直接利用 getSqlSession() 获得 , 然后直接注入SqlSessionFactory .
比起方式1 , 不需要管理SqlSessionTemplate , 而且对事务的支持更加友好 . 可跟踪源码查看

将我们上面写的UserDaoImpl修改一下

public class UserDaoImpl extends SqlSessionDaoSupport implements UserMapper {
   public List<User> selectUser() {
       UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
       return mapper.selectUser();
  }
}

2、在applicationContext.xml修改bean的配置

<bean id="userDao" class="com.kuang.dao.UserDaoImpl">
   <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

3、测试

@Test
public void test2(){
   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
   UserMapper mapper = (UserMapper) context.getBean("userDao");
   List<User> user = mapper.selectUser();
   System.out.println(user);
}

11. 声明式事务-利用AOP

事务就是把一系列的动作当成一个独立的工作单元，这些动作要么全部完成，要么全部不起作用。

1.事务四个属性ACID

原子性（atomicity）
事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用
一致性（consistency）
一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中
隔离性（isolation）
可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏
持久性（durability）
事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中

如果不进行事务的管理，则我们事务中有一个动作失败，其他的动作还会成功，这不是我们希望的，所以我们需要管理事务，让他们都成功才成功，有一个失败就都失败，我们可以通过Spring进行事务管理

2. spring中的事务管理

声明式事务：AOP
编程式事务：需要在代码中，手动编写try-catch逻辑进行事务的管理，繁琐

参考链接：尚硅谷spring117p

由于在service层中，每次进行批量增删改中，若有一个位置出错，则整个操作可以自动回滚，即一处失败则全部失败。
注意事务管理都在service层

1.配置声明式事务管理器

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

2.配置事务通知

设置切入点表达式对应的连接点的方法应该如何处理事务，若不设置则不会被事务进行管理，默认propagation传播方式为REQUIRED
propagation常用有两种：
REQUIRED：事务管理作用在当前方法的调用者，若其内有一个失败则全部失败
REQUIRES_NEW：作用在REQUIRES_NEW配置的方法上，若当前成功则事务成功，若其他事务失败则不影响当前事务
可以通过<tx:method name="*"/>表示当前切入点表达式对应的连接点中的所有方法

注意：必须导入的是tx包下的xmlns:tx="http://www.springframework.org/schema/tx

<tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="select" propagation="REQUIRES_NEW"/>
            <tx:method name="insert"/>
            <tx:method name="delete"/>
            <!--<tx:method name="*"/>-->  
        </tx:attributes>
    </tx:advice>

3. AOP织入事务

需要先导入aspectjweaverjar包

<dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>

将事务的通知通过切入点表达式作用到连接点上

<aop:config>
        <!--切入点-->
        <aop:pointcut id="pointcut" expression="execution(* com.yang.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>
    </aop:config>

4. 测试

总结

为什么需要配置事务？

如果不配置，就需要我们手动提交控制事务；
事务在项目开发过程非常重要，涉及到数据的一致性的问题，不容马虎！

11.SpringMVC

11.1 什么是MVC

MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。
是将业务逻辑、数据、显示分离的方法来组织代码。
MVC主要作用是降低了视图与业务逻辑间的双向偶合。
MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。

Model（模型）：(dao,service) 数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao）和服务层（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。

View（视图）：(jsp) 负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。

Controller（控制器）：(Servlet) 接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。

最典型的MVC就是JSP + servlet + javabean的模式。
在这里插入图片描述

11.2 创建web项目

在这里插入图片描述

IDEA中使用Tomcat部署
首先，需要先把向前项目通过maven打包，然后才能正常运行

11.3 Servlet

在这里插入图片描述

Servlet是Java提供的一门动态web资源开发技术
Servlet是JavaEE规范之一，其实就是一个接口，将来我们需要定义Servlet类实现Servlet接口，并由web服务器运行Servlet
导入servlet依赖：

在这里插入图片描述

11.4 springMVC执行流程

基于原生的Servlet，通过了功能强大的前端控制器DispatcherServlet，对请求和响应进行统一处理

执行流程：
1.servlet的注册：springmvc把原始的servlet封装成了DispatcherServlet前端控制器，servlet要想处理请求和响应，需要在web.xml中注册，并配置url-pattern，然后才能从浏览器中处理用户请求。
2.web关联springmvc的核心配置文件：前端控制器会读取SpringMVC的核心配置文件，所以需要配置springmvc配置文件，通过在web.xml中初始化参数<init-param>关联springmvc的配置文件，并且设置启动级别，使得在web服务器创建时就创建servlet对象并进行初始化
3.springmvc的核心配置文件：通过视图解析器获得Controller控制器中返回的逻辑视图，通过拼接试图名字，找到对应的视图，然后对视图进行渲染，最终转发到视图对应的页面

注意：(springMVC的核心配置文件名称为<servlet-name>-servlet.xml)

11.5 springmvc的配置

新建一个web项目
导入相关jar包
编写web.xml , 注册DispatcherServlet
编写springmvc配置文件
接下来就是去创建对应的控制类 , controller
最后完善前端视图和controller之间的对应
测试运行调试.

12. RestFul 风格

概念：Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

作用：地址栏相同，可以使用不同的提交方式实现不同的效果

13. 转发和重定向

有视图解析器，则默认进行转发，转发才会触发视图解析器拼接地址
重定向操作不能走视图解析器，因为不能访问WEB-INF下的内容

14. JSON-Jackson的使用

1.返回给前端固定的字符串：
可以不走视图解析器，通过@Controller配合@ResponseBody使用，或者直接用@RestController
在这里插入图片描述

14.1 使用步骤：

1.导入Jackson的jar包：

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
<dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
   <artifactId>jackson-databind</artifactId>
   <version>2.9.8</version>
</dependency>

配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
        version="4.0">

   <!--1.注册servlet-->
   <servlet>
       <servlet-name>SpringMVC</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
       <init-param>
           <param-name>contextConfigLocation</param-name>
           <param-value>classpath:springmvc-servlet.xml</param-value>
       </init-param>
       <!-- 启动顺序，数字越小，启动越早 -->
       <load-on-startup>1</load-on-startup>
   </servlet>

   <!--所有请求都会被springmvc拦截 -->
   <servlet-mapping>
       <servlet-name>SpringMVC</servlet-name>
       <url-pattern>/</url-pattern>
   </servlet-mapping>

<!--配置乱码的过滤器，使得get，post都不乱码 -->
   <filter>
       <filter-name>encoding</filter-name>
       <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
       <init-param>
           <param-name>encoding</param-name>
           <param-value>utf-8</param-value>
       </init-param>
   </filter>
   <filter-mapping>
       <filter-name>encoding</filter-name>
       <url-pattern>/*</url-pattern>
   </filter-mapping>

</web-app>

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

    <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
    <context:component-scan base-package="com.yang.controller"/>
    <!-- 让Spring MVC不处理静态资源 -->
    <mvc:default-servlet-handler/>
    <!--
   支持mvc注解驱动
       在spring中一般采用@RequestMapping注解来完成映射关系
       要想使@RequestMapping注解生效
       必须向上下文中注册DefaultAnnotationHandlerMapping
       和一个AnnotationMethodHandlerAdapter实例
       这两个实例分别在类级别和方法级别处理。
       而annotation-driven配置帮助我们自动完成上述两个实例的注入。
    -->
    <mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="UTF-8"/>
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="objectMapper">
                    <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                        <property name="failOnEmptyBeans" value="false"/>
                    </bean>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 后缀 -->
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

测试方法

@RequestMapping("/json3")
public String json3() throws JsonProcessingException {

   ObjectMapper mapper = new ObjectMapper();

   //创建时间一个对象，java.util.Date
   Date date = new Date();
   //将我们的对象解析成为json格式
   String str = mapper.writeValueAsString(date);
   return str;
}

15. 整合SSM

1.mybatis-config.xml —mybatis核心配置文件
2.database.properties----数据库配置文件
3.applicationContext.xml—spring核心配置文件，包含下列三个spring配置文件，需要在web配置文件中将其导入

spring-dao.xml配置文件主要负责dao层，并且需要配置mybatis配置文件(.mybatis-config.xml)
spring-service.xml配置文件主要负责service层，进行声明式事务等操作(AOP)
spring-mvc.xml配置文件主要负责controller层

4.web.xml：前端核心配置文件，配置serlvet

代码书写流程：数据库 —> pojo层 —> dao层 (mapper层) —> service层 —> controller层 --> 前端

**注意：**mysql 不要用狂神的，我的版本是8.0.28

前端可以用Bootstrap可视化布局系统，但是要在页面配置文件里，如jsp,html中配置Bootstrap链接

<link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">

白日梦想家24

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring框架+SPringleMVC-狂神版整理

狂神版本spring-springmvc笔记总结
复制链接

扫一扫

专栏目录