JAVA后端框架【spring】--超详解

什么是spring?

spring是一个轻量级的ioc和Aop的一站式java开辟框架，简化企业级开辟
轻量级：框架体积小（核心模块）
IOC

IOC:inversion of control 控制反转 把创建对象的控制权反转给spring框架
AOP

Aop:面向切面编程
将程序中一些公共的非业务代码分离提取出来，然后在业务代码执行时，给他们横切进来
使用动态署理机制实现，我们的业务代码，不显示调用，但是执行业务代码，会通过署理对象，调用非业务代码
spring体系结构

 搭建spring 

1.Maven 导入 spring 核心底子 jar

1. <!-- spring-context -->
2.         <dependency>
3.             <groupId>org.springframework</groupId>
4.             <artifactId>spring-context</artifactId>
5.             <version>5.2.2.RELEASE</version>
6.         </dependency>

复制代码

2.编写 spring 配置文件

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.        xmlns:context="http://www.springframework.org/schema/context"
5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
6.                      http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
7.    <!--开启spring注解扫描功能 指定扫描包-->
8.     <context:component-scan base-package="com.wph.springpro"> </context:component-scan>
9. </beans>
10. -----------------------------------------------------------------------------------------
11. <?xml version="1.0" encoding="UTF-8"?>
12. <beans xmlns="http://www.springframework.org/schema/beans"
13.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
14.        xsi:schemaLocation="http://www.springframework.org/schema/beans
15.                      http://www.springframework.org/schema/beans/spring-beans.xsd">
16.      &lt;!&ndash;
17.      在spriing的配置文件注册需要spring管理的类
18.      通过bean标签配置需要spring管理的类
19.      id=“对象名称，可以再getBean中获得spring生成的对象”
20.      class=“需要让spring管理的类的地址”
21.      scope="配置bean的作用于"
22.      scope="singleton"单例的(默认)，在spring框架启动时，就创建对象，而且是这种只创建一个对象
23.      scope="prototype"原型的（多例）在每次获得对象是，创建一个新的
25.      IOC指的是让spring框架创建对象，创建对象的同时，还有一个动作称为依赖注入
26.      依赖注入：在创建对象的时候，为对象中属性赋值
27.        一来注入两种方式：
28.         1.通过属性注入，属性的set方法
30.      &ndash;&gt;
31. &lt;!&ndash;   <bean id="user" class="com.wph.springpro.Model.User" scope="prototype">
32.     <property name="account" value="admin"></property>
33.         <property name="password" value="111"></property>
34.     </bean>&ndash;&gt;
36.     &lt;!&ndash;通过构造方法注入&ndash;&gt;
37.     <bean id="user" class="com.wph.springpro.Model.User" scope="prototype">
38.         <constructor-arg name="account" value="admin"></constructor-arg>
39.         <constructor-arg name="password" value="111"></constructor-arg>
40.     </bean>
42.     <bean id="AdminDao" class="com.wph.springpro.Dao.AdminDao"></bean>
43.     <bean id="Adminservice" class="com.wph.springpro.Model.Adminservice">
44.         <property name="adminDao" ref="AdminDao"></property>
45.     </bean>
46. </beans>

复制代码

3. 编写一个 User 实体类

1. package com.wph.springpro.Model;
3. import org.springframework.context.annotation.Scope;
4. import org.springframework.stereotype.Component;
6. @Component(value = "user")
7. @Scope(value = "prototype")
8. public class User {
9.     private String account;
10.     private String password;
12.     public User() {
13.         System.out.println("无参构造方法");
14.     }
16.     public User(String account, String password) {
17.         this.account = account;
18.         this.password = password;
19.     }
21.     public String getAccount() {
22.         return account;
23.     }
25.     public void setAccount(String account) {
26.         System.out.println("set");
27.         this.account = account;
28.     }
30.     public String getPassword() {
32.         return password;
33.     }
35.     public void setPassword(String password) {
36.         System.out.println("setpassword");
37.         this.password = password;
38.     }
40.     @Override
41.     public String toString() {
42.         return "User{" +
43.                 "account='" + account + '\'' +
44.                 ", password='" + password + '\'' +
45.                 '}';
46.     }
47. }

复制代码

 4.测试 spring

1.     /*
2.     ClassPathXmlApplicationContext是spring框架中的一个具体的实现类，负责生成，管理程序中对象
3.     可以看做是一个容器，所以一般把spring框架也称为spring容器，或ioc容器
4.     *
5.     * 控制反转  这是一种编程思想
6.     * 把对象生成的控制权，反转给spring框架，spring框架负责管理对象的整个生命周期
7.     *    对外提供获取对象的方法，我们在程序中哪里需要，哪里获取就行
8.     *
9.     * */
10.     public static void main(String[] args) {
11.         ApplicationContext applicationContext =new ClassPathXmlApplicationContext("spring.xml");
12.                                            User user=(User) applicationContext.getBean("user");
13.                                            User user1= applicationContext.getBean("user",User.class);
14.         System.out.println(user);
15.         System.out.println(user1);
16.     }

复制代码

 IOC(控制反转)
读作“反转控制”(Inverse of Control)更好理解，不是什么技能，而是一种 计划头脑，就是将原本在程序中手动创建对象的控制权，交由 Spring 框架来 管理。
IOC 容器负责对象的实例化、对象的初始化，对象和对象之间依赖关系、 对象的销毁、对外提供对象的查找等操纵，对象的整个生命周期都是由容器来 控制。
我们需要使用的对象都由 ioc 容器进行管理，不需要我们去手动通过 new 的方式去创建对象，由 ioc 容器直接帮我们组装好，当我们需要使用的时候直 接从 ioc 容器中直接获取就可以了。
正控：若要使用某个对象，需要自己去负责对象的创建
反控：若要使用某个对象，只需要从 Spring 容器中获取需要使用的对象， 不关心对象的创建过程，也就是把创建对象的控制权反转给了 Spring 框架.

Spring Bean 管理 

bean对象，由于把对象交给spring管理后，spring会对对象进行功能的增强，以是在spring框架中天生的对象，统一称为bean对象
基于 xml 配置方式

1. <!--
2.      在spriing的配置文件注册需要spring管理的类
3.      通过bean标签配置需要spring管理的类
4.      id=“对象名称，可以再getBean中获得spring生成的对象”
5.      class=“需要让spring管理的类的地址”
6.      scope="配置bean的作用于"
7.      scope="singleton"单例的(默认)，在spring框架启动时，就创建对象，而且是这种只创建一个对象
8.      scope="prototype"原型的（多例）在每次获得对象是，创建一个新的
10.      IOC指的是让spring框架创建对象，创建对象的同时，还有一个动作称为依赖注入
11.      依赖注入：在创建对象的时候，为对象中属性赋值
12.        一来注入两种方式：
13.   

复制代码

Xml 配置方式依赖注入 

1.通过属性注入，属性的set方法

1. <bean id="user" class="com.wph.springpro.Model.User" scope="prototype">
2.     <property name="account" value="admin"></property>
3.         <property name="password" value="111"></property>
4.     </bean>

复制代码

2.通过构造方法注入

1. <bean id="user" class="com.wph.springpro.Model.User" scope="prototype">
2.         <constructor-arg name="account" value="admin"></constructor-arg>
3.         <constructor-arg name="password" value="111"></constructor-arg>
4.     </bean>

复制代码

注解方式实现 

 开启注解扫描 context:component-scan base-package="包名"> context:component-scan>
注解创建对象
@Component(value=“user”)等同于
@Service
@Repository
以上注解都可以实现创建对象功能，只是为了后续扩展功能，在不同的层使用不 同的注解标记 @Scope(value=“prototype”) 原型
@Scope(value=“ singleton ”) 单例

1. /*
2.     sring注解方式bean管理 自动注入
3.       @Autowired是spring框架提供的注解
4.       用于在属性和属性的set方法上，如果写在属性上，set方法可以不需要
5.       默认情况下要注入的值不能为空 required=true
6.       自动注入有两种值的匹配方式
7.       1.通过属性类型查找
8.       2.通过对象的名字
9.         @Qualifier(value = "adminDao")
11.       @Repository 也是添加在属性上的，不需要添加set方法
12.                   注入的值不能为空的
13.                    也可以通过类型查找要注入的对象
14.                    也可以通过对象名字查找要注入的值 @Repository(value = "adminDao")
16.     */
17.     @Autowired
18.     //@Qualifier(value = "adminDao")
19.     AdminDao adminDao;
21.     public void save(){
22.         adminDao.save();
23.           adminDao.saveAdmin();
24.     }

复制代码

Spring 集成 Mybatis 

Spring 集成 Mybatis 其核心是将 SqlSessionFactory 交由 Spring 管理，并由 Spring 管理对 dao 接口的署理实现。
1.导入 mybatis jar 包

1. <!--mybatis jar-->
2.         <dependency>
3.             <groupId>org.mybatis</groupId>
4.             <artifactId>mybatis-spring</artifactId>
5.             <version>1.3.1</version>
6.         </dependency>
8.         <dependency>
9.             <groupId>org.mybatis</groupId>
10.             <artifactId>mybatis</artifactId>
11.             <version>3.4.2</version>
12.         </dependency>

复制代码

2.配置 sqlSessionFactory 

1. <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
2.         <property name="dataSource" ref="dataSource"></property>
3.         <property name="configLocation" value="classpath:mybatis.xml"></property>
4.         <property name="mapperLocations" value="classpath:Mappers/*Mapper.xml">
5.         </property>
6.     </bean>

复制代码

3.指定天生接口署理

1. <bean id="mapperFactory" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
2.         <property name="basePackage" value="com.wph.ssm.Dao"></property>
3.         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory">
4.         </property>
5.     </bean>

复制代码

4.在 service 中注入 Dao 署理接口，此接口有 Spring 署理实现

1. @Service
2. public class LoginService {
4.     @Autowired
5.     LoginDao loginDao;
7.     public  Admin findaccount(Admin admin){
8.         Admin admin1=loginDao.findAccount(admin);
9.         return admin1;
10.     }
12. }
13. ======================================================
14. <?xml version="1.0" encoding="UTF-8"?>
15. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
16.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
17. <mapper namespace="com.wph.ssm.Dao.LoginDao">
18.   <select id="findAccount" parameterType="Admin" resultType="Admin">
19.       select * from admin where account=#{account} and password=#{password}
20.   </select>
21. </mapper>
22. ========================================================================
24. public interface LoginDao {
25.     Admin findAccount(Admin admin);
26. }
27. =======================================================================
29. public class te {
30.     public static void main(String[] args) {
31.         ApplicationContext applicationContext= new ClassPathXmlApplicationContext("spring.xml");
32.         LoginService loginService= applicationContext.getBean("loginService",LoginService.class);
34.         Admin admin=new Admin();
35.         admin.setAccount("admin");
36.         admin.setPassword("111");
38.         Admin admin1=loginService.findaccount(admin);
39.         System.out.println(admin1);
40.     }
41. }

复制代码

注解与 XML 的对比

注解优点： 方便,直观,高效（代码少，没有配置文件的书写那么复杂）。
注解缺点：以硬编码的方式写入到 Java 代码中，修改是需要重新编译代码的。
xml 优点是： 配置和代码是分离的,在 xml 中做修改，无需编译代码，只需重 启服务器即可将新的配置加载。
xml 的缺点是：编写贫困，效率低，大型项目过于复杂。
AOP

面向切面编程：面向对象编程的补充连续
面向切面编程头脑：
将程序中一些公共的非业务代码（提交事件，打印日志，权限验证，统一异常处置惩罚）分离提取出来，然后在业务代码执行时，通过一个署理对象资助我们调用这些提取出来的非业务代码，如许在业务代码不消显示调用非业务代码，做到业务代码和非业务代码分离，低落耦合度，给他们横切进来
使用动态署理机制实现，我们的业务代码，不显示调用，但是执行业务代码，会通过署理对象，调用非业务代码
原理：动态署理模式，给业务代码天生署理对象
AOP编程头脑是java中的，不是spring专用的
是spring 使用AOP这一编程头脑
毗连点：类中可以被增强（加功能）的方法
切入点：类中现实被增强的方法
目标（target）：署理目标类（毗连点，切入点所在的类）
署理（proxy）：向目标对象应用关照时创建的署理对象
关照：向毗连点添加的功能
AOP 的根本概念

@Before 前置关照：业务方法执行之前 ，调用关照
@After 后置关照：业务方法执行之后,无论是否出现异常
@AfterReturnning 返回关照：方法成功执行之后关照,出现异常不执行
@AfterThrowing 异常关照：当业务代码出现异常时，抛出异常之后关照
@Around 环绕关照：方法执行前后都有关照 基于注解方式的实现
启动 AspectJ 支持:

1. <aop:aspectj-autoproxy />

复制代码

2. @Component
3. @Aspect
4. public class communt {
6.    // @Before("execution(* com.wph.springpro.Dao.AdminDao.*(..))")
7.    // @After("execution(* com.wph.springpro.Dao.AdminDao.*(..))")
8.    @AfterReturning("execution(* com.wph.springpro.Dao.*.*(..))")
9.     public void printdiolg(){
10.         System.out.println("打印日志");
12.     }
14.     @AfterThrowing(value = "execution(* com.wph.springpro.Dao.*.*(..))")
15.     public void commit(){
16.         System.out.println("提交事务");
17.     }
18. /*
19.           @Around 环绕通知 可以在业务方法执行之前，之后，出现异常时添加功能
20.           ProceedingJoinPoint joinPoint 表示目标方法
21. */
22.     @Around(value = "execution(* com.wph.springpro.Dao.*.*(..))")
23.     public void around(ProceedingJoinPoint joinPoint){
24.         System.out.println("前置通知");
25.         try {
26.             Object object= joinPoint.proceed();//调用目标业务方法
27.             System.out.println("返回通知");
28.         } catch (Throwable throwable) {
29.             throwable.printStackTrace();
30.             System.out.println("异常通知");
31.         }
32.         System.out.println("后置通知");
33.     }
34. }

复制代码

 springAOP 实现

下载 AOP 相干 jar

1. <dependency>
2. <groupId>org.springframework</groupId>
3. <artifactId>spring-aspects</artifactId>
4. <version>5.2.2.RELEASE</version>
5. </dependency>

复制代码

Spring 事件管理 

事件管理本质上是数据库提供的一种管理机制
数据库事件管理是对一次数据库操纵过程中执行的多条语句进行管理，确保一次操纵过程中的多条sql要么执行成功，要么都不执行，从而确保数据一致性
spring事件管理是spring框架对事物提交这一功能进行封装，程序员在业务开辟中不需要的提交事件，sqlsession.commit()
1.编程式事件管理

需要程序员在代码中自己控制事件提交和回滚
2.声明式事件管理

声明事件底层使用了AOP头脑，可以为方法添加事件功能，它的控制是方法级别的
@Transactional可以添加在方法上，也可以添加到类上面，如果添加到类上面，此类中所有的方法都在spring事件管理中进行
声明式事件失效场景：

1.@Transactional用在非public方法上

2.方法中的异常被捕捉了，认为方法没有异常

3.方法中出现编译期异常，照旧会提交事件

4.数据库引擎不支持事件 mysql中只有innodb引擎支持事件的

1. @Transactional
2.     public void insert(){
3.         String sql = "INSERT INTO admin (account, password) VALUES (?, ?)";
4.         jdbcTemplate.update(sql, "zhangsan", "1111");
5.         //System.out.println(10/0);
6.         String sql1 = "INSERT INTO admin (account, password) VALUES (?, ?)";
7.         jdbcTemplate.update(sql1, "lisi", "1111");
8.     }
9.     public void delete(){
10.         System.out.println("删除");
11.     } public void udate(){
12.         System.out.println("修改");
13.     }

复制代码

配置事物管理器

1. <!-- 配置 spring 事务管理器-->
2. <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
3. <property name="dataSource" ref="dataSource"></property>
4. </bean>

复制代码

注解方式

1. <!-- 开启注解事务管理 -->
2. <tx:annotation-driven transaction-manager="transactionManager"/>

复制代码

 总结

为什么需要配置事件？

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

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。