狂神笔记链接：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/beanshttp://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/beanshttp://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/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsd">
<beans>

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

@Autowired

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

public class User {@Autowiredprivate Cat cat;@Autowiredprivate 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 : 目标对象@Overridepublic 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 被调用的目标对象@Overridepublic 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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://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 {@Testpublic 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 {@Testpublic 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/beanshttps://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执行，在现在，都是用sqlSessionTemplateprivate 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/beanshttps://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.测试使用

@Testpublic 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.DateDate 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">

Spring框架+SPringleMVC-狂神版整理相关推荐

Spring学习笔记-狂神版
1|0前言 Mybatis学完开始学Spring 同样先放上参考文档,现在只是需要短时间之内要过一下基础,等考完研再看要不要深入学习吧. B站 https://www.bilibili.com/vid ...
手把手Maven搭建SpringMVC+Spring+MyBatis框架(超级详细版)
手把手Maven搭建SpringMVC+Spring+MyBatis框架(超级详细版) SSM(Spring+SpringMVC+Mybatis),目前较为主流的企业级架构方案.标准的MVC设计模式, ...
解鞍卸甲——手写简易版Spring框架（终）：使用三级缓存解决循环依赖问题
什么是三级缓存按照目前我们实现的 Spring 框架,是可以满足一个基本需求的,但如果你配置了A.B两个Bean对象互相依赖,那么立马会抛出 java.lang.StackOverflowError ...
Spring框架整理
目录 1.说一下 IOC 和 AOP? 2.Spring 里面的注解autowired 和 resource 区别? 3.依赖注入的方式有几种,哪几种? 4. springIOC 原理?自己实现 IO ...
手写简易版Spring框架（七）：定义标记类型接口Aware，实现感知容器相关的信息
文末有惊喜目标目前已实现的 Spring 框架,在 Bean 操作上能提供出的能力,包括:Bean 对象的定义和注册,以及在操作 Bean 对象过程中执行的,BeanFactoryPostProc ...
程序员开发必备英语基础–狂神版
程序员开发必备英语基础–狂神版一.开发常用英语词汇排序 A array数组 accessible 可存取的 area面积 audio 音频 addition 加法 action 行动 arithme ...
Spring框架学习路线
文章目录 1.Spring 1.1.简介 1.2.优点 1.3.扩展 2.IOC理论 2.1.IOC的创建对象的方法 3.Spring配置 3.1.Bean配置 3.2.import 4.依赖注入 4 ...
【Spring】（1）Spring概述：什么是Spring框架？为什么要用Spring框架？
两个月前跟着b站动力节点王鹤老师的Spring框架教程视频学习完了Spring框架,在学习过程中我将视频中涉及的代码都一行一行手敲了一遍,并且把Spring入门相关的资料整理了一下,在这里记录一下我在 ...
spring框架基础与他方问
Spring框架-控制反转(IOC) 1 Spring框架概述 1.1 什么是Spring Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Jo ...

Spring框架+SPringleMVC-狂神版整理