首页  思维导图  详情

spring

2022-04-02 17:33:11   196  举报





AI智能生成

为你推荐

查看更多



架构设计、系统架构、微服务、分布式、spring、spring boot、spring cloud

spring整合mybatis 原理

spring源码解析

spring

Spring

作者其他创作

大纲/内容

使用多配置文件就是spring中管理类的applicationContext.xml文件 1、多配置文件，每个单独的文件就很小了，读取的效率也会提高 2、避免了冲突，已经多人开发带来的竞争如果项目有多个模块，一个模块一个配置文件比如：之前写的学生管理系统 - 学生信息管理使用一个配置文件 - 班级管理使用一个配置文件按照类的功能进行分配，数据库相关的类放在一个配置文件，做事务管理的一个配置文件 service的一个配置文件等；

学生模块和学校模块分开 spring-student.xml spring-school.xml 需要一个主配置文件进行包含，当我们加载主配置文件的时候，会把主配置文件中包含的配置文件加载到spring容器中 total.xml 包含必须用到的东西：classPath: 规定的是target/classes/作为根目录

1、直接指定路径包含 <import resource=\"classPath:demo04/spring-student.xml\"/> <import resource=\"classPath:demo04/spring-school.xml\"/>

2、使用通配符的形式 <import resource=\"classPath:demo04/spring-*.xml\" />

【注意】：这个通配符包含的文件不能包括主配置文件本身，否则会出现加载死循环并且使用这个通配符的形式，这些xml文件必须放在一个目录之下，否则无法加载这是官方文档中的声明

【注意】

多配置文件的包含关系

建议使用多配置文件

建议

<context:property-placeholder location=\"classpath:student.properties\"/>

1、spring配置文件读取properties配置文件

小知识点

出现在2003年左右，是为了解决企业级开发的难度，减轻对项目模块之间的管理\t\t\t类与类之间的管理，帮助开发人员创建对象，管理对象之间的关系\t\t\tspring的核心是ioc和aop，能实现模块之间，类之间的解耦合

官网

官网：spring.io

spring简介

概要

控制反转（Inversion of control）：原本是程序员自己创建对象，给属性赋值。并且管理类与类之间的关系。现在是spring框架，也就是spring容器来创建对象，给属性赋值，管理类与类之间的关系，实现类与类之间，模块与模块之间解耦合

1、关于ioc的概念

就是依赖注入：只需要在程序中提供需要创建的对象的名称即可\t\t\t其他的操作都是容器完成的

2、IOC的技术实现，就是使用DI（Dependency Injection）

<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.2.5.RELEASE</version> </dependency>

1、在maven中添加依赖

告诉spring创建对象，声明bean，告诉spring，我们需要创建哪个对象 id：自定义名称，唯一 class：创建的类的全限定名称底层需要反射机制实例化对象，因此，不能使用接口这个时候spring就会执行这样的代码 SomeService someService = new SomeServiceImpl(); 然后将这个对象放进map集合中 map.put(\"SomeService\

直接使用xml-configuration File 然后选择spring-config，创建一个applicationContext.xml的spring配置文件

在根标签<beans>下加入类配置信息<bean id=\"唯一的标识\" class=\"需要创建的类对象的全限定名称\" />

2、编写spring的配置文件，也就是ApplicationContext.xml

1、声明配置文件位置：target/classes是根目录。

2、spring容器加载配置文件，ApplicationContext ac = new ClassPathXmlApplicationContext(配置文件);

3、使用ac.getBean(对应的那个配置文件的bean的ID);

4、获取对象以后强制类型转换成自己需要的，然后调用方法

3、在程序中使用spring来完成对象的创建

1、在执行读取配置文件信息的时候就会创建对象，创建对象会调用无参构造

获取创建对象的数量：ac.getBeanDefinintionCount();

获取所有对象的名称： String [] names = ac.getBeanDefinitionNames();

2、关于spring中获取创建对象的数量以及创建对象的名称

关于spring的执行时机

3、spring创建对象的步骤

di：依赖注入，表示创建对象，给对象赋值 di的实现方式有两种 1、在spring配置文件中，使用标签和属性完成，叫做基于XML的di实现 2、使用spring中的注解，完成属性赋值，叫做基于注解的di实现

1、set注入（设值注入）：spring调用类的set方法进行属性的赋值。 2、构造注入：spring调用类的有参数构造方法。创建对象。创建时完成赋值；

概念

1、spring调用类的set方法进行属性的赋值。

1、实际上是spring底层调用了set方法进行赋值，因此必须有set方法，没有会报错！ 2、这个name不是指类中的属性，他底层肯定是通过反射机制找到哪个对应的set方法比如：id 就会去找setId 因此：他是根据set方法进行访问的如果此时<property name=\"email\" value=\"lisi@qq.com\" /> 这个时候即使没有email这个属性，只要有setEmail方法就不会出错【那个set方法必须有参数】

基本类型的设值注入：(基本数据类型和String)

1、在进行set注入的时候，有的属性值是一个引用数据类型我们对于引用数据类型需要使用<property name=\"school\" ref=\"myschool\" /> 的形式，让他找到这个引用数据类型

2、现在，使用byName命名规则，spring会自动查找进行赋值，不需要手动赋值给当前bean声明autowire属性：autowire=\"byName\

byName

如果autowire属性值是：byType，这个时候，spring就会根据这个引用数据类型去查找这个数据比如说：private School school; 他就会去beans中查找这个School引用数据类型说白了就是，private School school = new School();

同源关系有三种，都可以符合 1、当前javabean对应的类中的引用数据类型和beans中的某个class相同 2、当前javabean对应的类中的引用数据类型在beans中有个class是他的子类 2、当前javabean对应的类中的引用数据类型在beans中有个接口实现类 1、private School school = new School(); 2、private School school = new SmallSchool; 3、private School school = new SchoolImpl();

byType

自动注入

引用类型的设值注入

set注入，设值注入

1、直接使用name和value的形式，name就对应类中的属性名

<constructor-arg index=\"0\" value=\"1002\"/> <constructor-arg index=\"1\" value=\"王五\"/> <constructor-arg index=\"2\" ref=\"school\"/>

2、使用index下标的形式，从0开始，指代每个位置上的参数

<constructor-arg value=\"1002\"/> <constructor-arg value=\"王五\"/> <constructor-arg ref=\"school\"/>

3、默认按照位置进行赋值

构造注意前提就是必须有构造方法

构造注入

基于xml配置文件的DI实现

2、@Repository，创建对象，用在持久层中，dao接口实现的上面

3、@Service，创建对象，用在业务逻辑层，在service实现类的上面，有事务处理的功能

4、@Controller，控制层对象，用来接收用户输入，进行结果展示

通过id，也就是名字来进行查找

1、byName

默认的是这种方式，通过数据类型来进行查找，只要符合同源类型即可

2、byType

当使用byName的时候，有一个注解叫做@Qualifier是用来赋值的

6、@Autowired，自动注入，针对的是引用类型，有两种注入的方式

1、没有手动给这个引用数据类型附上值，则如果没有找，就会使用byType

2、手动赋值以后，没有找到就会报错

通过javabean中的id，和属性值进行匹配

根据类型来进行查找，同源关系

7、@Resource。自动注入，这个不是spring自带的，是JDK中自带的注解

1、在maven中加入依赖，spring-context，加入这个依赖会自动的加入spring-aop依赖，注解使用的就是srping-aop.jar

2、在类中加入注解

把每个包都写出来<context:component-scan base-package=\"com.javase.domain\" /> <context:component-scan base-package=\"com.javase.dao\" /> <context:component-scan base-package=\"com.javase.service\" />

1、一次加入多个

<context:component-scan base-package=\"com.javase.service; com.javase.domain; com.javase.dao\" />

<context:component-scan base-package=\"com.javase\" /> 这里建议时不要使用在高一级的包，因为文件夹越深效率越低

3、扫描父包

加入扫描包的三种方式

3、在配置文件中声明组件扫描器，通知spring去扫描哪些包寻找对象，并创建对象，<cotext:component-scan > base-package=\"包名\"

1、编写properties配置文件

<context:property-placeholder location=\"classpath:student.properties\"/>

2、在spring配置文件中声明这个属性配置文件

@(value=\"${name}\")private String name;

3、在需要的地方比如说属性上

4、使用配置文件进行赋值操作

@Value(\"#{}\") 其实是SpEL表达式的值，可以表示常量的值，或者获取bean中的属性

5、通过Value(\"#{属性}\")获取值

注解的实现步骤

基于注解色DI实现

目的：实现业务逻辑之间的解耦合，比如：service和dao

4、spring容器创建对象进行属性赋值

spring-ioc:控制反转

使用Proxy，Method，InvocationHandle来创建代理对象，条件是必须有接口

1、使用JDK动态代理

要求就是他的方法不能是final的，属性不能是final的，实际底层通过继承的原理实现代理类

2、使用CGlib第三方工具库动态代理

1、在不修改源代码的情况下，对某个类中的方法进行功能的增强

2、减少重复代码

3、让程序员专注于业务逻辑代码的编写

4、让程序解耦合，业务功能，日志功能，事务处理功能等都分开了，互相之间的联系不紧密

动态代理的优点，功能

1、spring中的动态代理

1、aop就是（Aspect Orient Programming），面向切面编程，是基于动态代理实现的可以使用jdk自带的动态代理，也可以使用cglib第三方工具库。aop就是动态代理的规范化他把动态代理的实现步骤已经完成了，开发人员只需要通过一定的规范就行为和使用即可

1、在分析业务功能的时候，分析出哪些功能是切面功能，找到合适的切面

2、合理的安排切面的执行时机，在目标方法的前面还是目标方法的后面

切入点表达式

3、合理的安排切面的执行位置，在哪个类上，在哪个方法上

比如说有一个业务逻辑是这样的。需要在用户进行购买商品的时候记录下的操作的时间，token等信息的时候。就可以使用AOP，分析出一个切面，创建一个切面增强方法，完成业务逻辑。

2、怎么理解面向切面编程：

1、在不修改源代码的情况下，增强功能

2、减少代码的重复

3、程序员可以专注于业务逻辑的实现

4、解耦合，业务逻辑。事务处理，日志管理等之间解耦合

3、aop的作用

1、给系统中已经存在的一个类增加功能，在不修改源代码的情况下增加功能

2、项目中多个类都需要实现同一个功能

3、给业务方法增加事务，或者日志输出等

4、什么时候考虑使用aop

2、aop是什么？

1、Asepect：切面的，就是一个类，比如：MyAspect.java这个类，这个类中有方法，方法就是切面方法，目的是增强功能的。是给业务逻辑代码，常见的有，日志输出，事务处理，统计信息，参数检查，权限验证等

2、JoinPoint：连接点，就是指某个目标方法，那就是一个切入点，连接业务方法和切面的位置，就是那个业务方法

3、Pointcut：切入点，就是多个连接点的集合，多个方法

4、目标对象，就是需要增强功能的那个类

5、Advice：通知，也可以称之为增强，通知切面的执行时间，是在方法前，还是在方法之后？

3、相关术语

1、必须有切面的功能代码，就是用来增强业务的代码

2、必须有切入点，就是切面的执行位置

3、必须有通知，就是通知切面的执行时间

4、一个切面必须要有的三要素：

spring框架内部实现了aop，可以使用aop进行工作，一般都是在事务处理中使用aop，但是spring使用aop比较繁琐，麻烦

1、spring

是另一个框架，是专门用来做aop的，spring框架已经集成了aspectJ框架通过spring，可以使用aspectJ的aop功能

1、使用xml配置文件，配置全局事务

2、使用注解开发，5个注解

AspectJ的两种使用方式

2、AspectJ

5、关于aop的实现

1、添加spring依赖

2、添加aspectJ依赖

3、创建接口和接口实现类

4、创建切面类增强功能，执行切面的执行位置，切面的执行时间

5、将对象交给spring容器进行管理

<aop:aspectj-autoproxy proxy-target-class=\"true\"/>【必须声明】

6、声明代理对象的配置信息

1、aspectJ的实现步骤

切入点表达式，是使用在注解上的，是声明这个注解，也就是这个切面的执行位置

语法规则：execution(访问控制修饰符返回值类型包名.类名.方法名(形参列表)）抛出异常 )

execution(public * *(..)) 指定切面执行的位置：表示所有公共的方法 execution(* set*(..)) 只有连个参数：返回值方法名(参数) 指定切面执行的位置：表示所有以set开头的方法 execution(* com.javase.service.*.*(..)) 指定切面执行的位置：表示com.javase.service下的所有类中的所有方法，方法参数任意 execution(* com.javase.service..*.*(..)) 指定切面执行的位置：表示com.javase.service包及其子包下的所有类的所有方法 execution(* *..service.*.*(..)) 指定切面执行的位置：表示所有路径下的service包中的所有类的所有方法比如： com.javase.service. com.javase.dao.service. crm.javase.service.

* 匹配任意一个或者多个字符 .. 使用在参数上，表示有0个或者多个参数使用在包上，表示当前包和子包 + 使用在类上，表示当前类和子类使用在接口上，表示当前接口及其实现类

2、切入点表达式，确定切面的执行位置

1、关于参数：JoinPoint jp：每个通知都可以有这个参数，这个参数如果出现必须是第一个位置上2、这个参数是用来获取目标方法的签名的3、使用方法： - 获取签名：Signature sign = jp.getSignature(); - 获取方法名：String name = sign.getName(); - 获取参数：Object [] args = jp.getArgs();

@Before(value=\"execution(* *..service.*.do*(..))\")public void doBefore(){}

1、必须使用在类上2、必须指定切入点表达式3、返回值为void4、没有参数，有的话只有一个

1、@Before：前置通知

@AfterReturning(value=\"execution()\

1、关于基本数据类型和String，在这个类中修改不影响返回值

2、如果是引用数据类型，使用set方法进行了数据的改动，则返回的那个数据就会有变化

1、必须使用在类上2、必须指定切入点表达式3、没有返回值4、有参数，Object res ，如果还有就是jp5、这个参数的名称必须和注解中的returning相同

2、@AfterReturning：后置通知

@Around(value=\"execution()\")public Object doAround(ProceedingJoinPoint pjp){ Object res = null; //在前面加强 res = pjp.proceed();//执行目标方法 //在后面加强 return res;}

1、必须使用在类上2、必须指定切入点表达式3、返回值为Object4、参数只有一个就是ProceedingJoinPoint5、使用pjp.proceed()就是执行目标方法，等价于 method.invoke()6、可以改变返回值结果，可以进行中间阶段的判断7、因为pjp的父类是JoinPoint，可以读取参数，进行判断8、几乎就是那个Proxy中的InvocationHanler接口实现类

3、@Around：环绕通知

@AfterThrowing(value=\"execution()\

4、@AfterThrowing：异常通知

@After(value=\"execution()\")public void doAfter(){}

1、必须使用在类上2、必须指定切入点表达式3、没有返回值4、没有参数，如果有就是jp5、他的实际意义就是 try{ 目标方法执行 }catch (Exception e){ 如果出现异常信息，就会e.printStackTrace(); }finally{ 【总是被执行】 }

5、@After：最终通知

1、使用注解@Pointcut，来对切入点表达式进行定义和管理 2、出现在方法的上面 - 这个方法没有返回值 - 这个方法的方法体没有代码 - 这个方法没有参数 3、这个方法的方法名就是这个定义的切入点表达式的别名使用的语法规则： @Pointcut(value=\"execution(表达式)\") private void mypt(){ } 因为这个表达式一般都是在本类中进行使用，因此定义为private 并且，这个方法名mybt就是这个表达式的别名

6、@Pointcut：切入点表达式管理的注解就是省力了，如果有多个一样的切入点表达式直接就用那个别名了

3、通知，Advice，使用5个注解完成，确定切面的执行时间

1、spring已经集成了cglib代理

2、cglib代理不需要接口就能实现，底层原理是通过集成

3、如果没有使用接口，底层创建代理对象使用的就是cglib

<aop:aspectj-autoproxy proxy-target-class=\"true\" />

4。如果使用接口也可以使用cglib，需要在配置文件中进行设置

4、cglib动态代理的实现

6、AspectJ框架的具体实现

spring-aop：面向横切面编程

就是spring框架使用ioc技术将mybatis的对象交给spring来进行统一创建和管理

例如：service对象，dao对象，工具类对象，控制层对象

1、spring整合mybatis的想法

1、加入spring依赖 2、加入mybatis依赖 3、加入mysql驱动依赖 4、加入单元测试junit依赖 5、加入spring事务处理的依赖 6、加入druid连接池的依赖 7、加入spring和mybatis集成的依赖 8、加入pagehelper分页依赖需要在mybatis配置文件中加入插件信息 <plugins> <plugin interceptor=\"com.github.pagehelper.PageInterceptor\" /> </plugins>

1、在maven中加入依赖

2、创建实体类

3、创建dao接口

4、编写sql映射文件（mapper文件），也就是每个数据库dao对应的xml配置文件

5、编写mybatis主配置文件

6、编写service及其实现类

<bean id=\"dataSource\" class=\"com.alibaba.druid.pool.DruidDataSource\"> <property name=\"url\" value=\"${jdbc_url}\"/> <property name=\"username\" value=\"${jdbc_user}\"/> <property name=\"password\" value=\"${jdbc_pwd}\"/> <property name=\"maxActive\" value=\"${jdbc_max}\"/> </bean>

就是数据库连接池：druid

1、dataSource数据源对象

<bean id=\"sqlSessionFactory\" class=\"org.mybatis.spring.SqlSessionFactoryBean\"> <property name=\"dataSource\" ref=\"dataSource\"/> <property name=\"configLocation\" value=\"classpath:mybatis.xml\"/> </bean>

就是sqlSessionFactory

2、mybatis主配置文件加载的SqlSessionFactoryBean对象

<bean class=\"org.mybatis.spring.mapper.MapperScannerConfigurer\"> <property name=\"sqlSessionFactoryBeanName\" value=\"sqlSessionFactory\"/> <property name=\"basePackage\" value=\"com.javase.dao\"/> </bean>

3、dao对象，就是数据库操作类的实现类，这里使用的还是代理类的形式

4、创建service业务处理

7、创建spring配置文件，将mybatis中需要的对象交给spring容器管理

8、创建测试类，获取service对象，通过service调用dao完成数据的处理

2、开发步骤

3、spring整合的mybatis的事务是自动提交的

4、关于spring配置文件中读取属性配置文件

spring-mybatis整合开发

是指在一个业务中（一个业务划分的最小单元），涉及到多张表，或者是多条DML语句共同参与，并且要求这几条DML语句同时成功，或者同时失败，才能完成业务逻辑。那么几条DML语句捆绑执行，同时成功同时失败，这个整体就是一个事务，比如银行转账，必须两个账户的余额更新同时成功或者同时失败

1、什么是事务？

2、以前怎么处理事务？

每一种数据库访问技术都有自己的一个事务的处理方式，没有一个统一的规范化，不利于开发

3、不足之处？

优点：spring将各种不同类型的数据访问技术都集成了，提供了一个事务的统一模型即使是不同类型的数据访问技术，也可以使用这个步骤

4、spring处理事务有什么优点？

1、spring使用事务管理器机制，使用事务管理器对象完成事务的提交和回滚

2、事务管理器是由接口和他的众多实现类构成的

3、接口：PlatformTransactionManager，定义了事务的重要方法，commit和rollback 实现类：spring把每种数据库访问技术的对应的事务处理的实现类都定义好了 mybatis访问数据库 ---> DataSourceTransactionManager hibernate访问数据库 ---> HibernateTransactionManager

5、spring怎么处理事务？

1、告诉spring，你需要使用哪种数据库访问技术

2、在spring配置文件中声明这个类型，就是对应的事务的管理器对象的实现类

Mybatis <bean id=\"transactionManager\" class=\"DataSourceTransactionManager\"> <property name=\"dataSource\" ref=\"dataSource\" /> </bean>

6、spring怎么使用事务？

默认的

1、DEFAULT：spring默认的隔离级别，读已提交

2、READUNCOMMIT：读未提交（脏读）

3、READCOMMIT：读已提交

4、REPEARABLE_READ：可重复读

5、SERIALIZABLE:序列化读

1、事务的隔离级别

如果已经有事务，则使用当前事务，如果当前没有事务，会新建事务

1、propagation_required

当前方法支持事务，就是有事务可以，没有事务也可以，支持：supports

2、propagation_supports

当前方法必须有事务，及时他在的这个方法已经有事务，这个事务必须挂起，等待当前的事务

3、propagation_requires_new

你要调用我，你必须有事务，没有事务就报错支持当前事务；如果不存在当前事务，则抛出异常。

4、propagation_mandatory

如果存在当前事务，则在嵌套事务中执行，行为如下propagation_required不然的话。

5、propagation_nested

不支持当前事务；如果存在当前事务，则抛出异常。

6、propagation_never

不支持当前事务，而是始终以非事务方式执行。

7、propagation_not_supported

2、事务的传播行为

timeout

默认

- 就是指当前事务执行的最大时间，如果超过了这个时间，事务就会回滚 - 一般都是不设置的，单位是s（秒） TIMEOUT_DEFAULT 使用基础事务系统的默认超时，如果不支持超时，则不使用。

3、事务的超时时长

事务的属性

7、事务有哪些处理机制，哪些事务类型

1、注解方式是spring自带的事务处理的方式，适合中小型项目

- 创建事务管理器对象- 声明使用哪种数据库的数据源

1、声明事务管理器对象

- 声明注解式开发- 指定事务管理器对象- 切记这里是 tx:annotation-driven

xmlns:tx=\"http://www.springframework.org/schema/tx\"http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd

<tx:annotation-driven transaction-manager=\"transactionManager\"/>

2、告诉spring我们将使用注解的形式进行事务的控制

1、使用@Transactional注解进行开发

2、这个注解一般都是出现在方法上，就是需要控制事务的那个类，一般不在类上，因为不是所有的方法都需要进行事务的控制

1、Propagation(事务的传播方式) -----> Propagation.REQUIRED

2、isolation（事务的隔离级别） -----> Isolation.DEFAULT

3、readOnly（数据库信息是否只读，这个针对于查询，提高效率） -----> false

4、timeout（处理事务的超时时间） -----> -1

5、rollbackFor(指定需要回滚的异常类，是Class[]数组) ----->

6、rollbackForClassName（指定需要回滚的异常类类名） ----->

7、noRollbackFor：指定不需要回滚的异常类。

8、noRollbackForClassName：指定不需要回滚的异常类类名。类型为 String[]，

3、@Transactional的属性

环绕通知实现

@Around() public Object doAfter(ProceedingJoinPoint pjp){ spring开启事务 try{ pjp.目标方法执行() spring提价事务 } catch ( Exception e ) { spring回滚事务 }finally{ spring关闭事务 } }

4、底层实现原理

3、使用注解进行事务控制

2、使用spring注解控制事务的步骤

8、使用注解的方式进行事务的处理

1、使用aspectJ框架进行事务的处理，适合于中大型项目的开发

新加入 aspectj 的依赖坐标 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> <version>5.2.5.RELEASE</version> </dependency>

1、加入新的依赖，使用aspectJ依赖

2、创建事务管理器对象，告诉spring我们使用的是那种数据库访问技术

1、通知某个方法使用哪种事务的处理方式（隔离级别，传播行为，超时时间等）

2、id：id是自定义的

3、transaction-manager：事务管理器对象，使用使用上面定义的管理器对象

4、<tx:attributes>：就是设置事务的属性

5、<tx:method name=\"buy\"：就是针对某个或者某些方法

6、rollback-for：这个抛出异常必须是全限定名称

<tx:advice id=\"buyAdvice\" transaction-manager=\"transactionManager\"> <tx:attributes> <tx:method name=\"buy\" propagation=\"REQUIRED\" isolation=\"DEFAULT\" read-only=\"false\" rollback-for=\

3、配置事务通知（就是事务的属性，就是那个注解中的相关参数-->@Transactional(参数信息)）

1、上面的事务已经设置完毕，那么这个事务到底是针对于那个方法？那个类中中的方法？

2、需要配置一个增强器：就是指定你配置好的那个事务，到底是给谁用的

3、这个地方需要配置一个aop

xmlns:aop=\"http://www.springframework.org/schema/aop\" http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd

<aop:config>  <aop:pointcut id=\"servicept\" expression=\"execution(* *..service..*.*(..))\"/>  <aop:advisor advice-ref=\"buyAdvice\" pointcut-ref=\"servicept\"/> </aop:config>

4、配置增强器

9、使用aspectJ的aop进行事务的处理

spring-事务处理机制

1、使用模板创建项目，webapp项目

2、增加目录，java，resource等标准的web开发目录结构

1、自动添加了junit单元测试依赖

2、添加spring-context框架依赖

3、添加spring-tx，事务处理依赖

5、添加mybatis依赖

6、添加spring-mybatis集成依赖

7、添加mysql驱动依赖

8、添加druid数据库连接池依赖

9、添加aspectJ处理事务的依赖

10、添加java.servlet-api依赖

11 、添加jsp-api依赖

12、添加github中的分页处理工具依赖

<dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>5.2.5.RELEASE</version> </dependency>

13、添加获取spring容器的web依赖

3、配置pom文件添加对应依赖

1、环境配置

4、编写实体类

5、编写dao接口及mapper文件

6、配置mybatis主配置文件

7、编写service及其实现类

8、编写spring配置文件，将对象交给spring容器进行管理

9、创建controller控制层servlet，进行控制层操作

2、业务处理，三层架构配置

XML文件中配置 <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:applicationContext.xml</param-value> </context-param>

配置spring配置文件的位置，可以被ContextLoaderListener读取到

String key = WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE;// WebApplicationContext ac = (WebApplicationContext) this.getServletContext().getAttribute(key);

1、直接获取

WebApplicationContext ac = WebApplicationContextUtils.getRequiredWebApplicationContext(this.getServletContext());

2、通过WebApplicationContextUtils工具进行获取

3、spring容器对象的获取的方法

spring-web开发部署

spring