spring基础知识

一、spring

1.spring目的

• spring目的是解决企业级应用的复杂性。
• spring理念：使现有技术更加容易使用，整合了现有的技术框架。

2.spring是什么

• spring是一个开源的、轻量级的、非侵入式的、控制反转和面向切面的容器框架。

3.spring组成

• spring core
• AOP
• ORM
• DAO
• Web
• Context
• Web MVC

4.spring配置

4.1.别名配置

• 第一种

  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. xsi:schemaLocation="http://www.springframework.org/schema/beans
  5. https://www.springframework.org/schema/beans/spring-beans.xsd">
  7. <bean id="hello" class="com.sywl.entity.Hello">
  8. <constructor-arg name="name" value="张三"/>
  9. </bean>
  10. <alias name="hello" alias="hello3"/>
  11. </beans>

• 第二种：可以起多个别名

  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. xsi:schemaLocation="http://www.springframework.org/schema/beans
  5. https://www.springframework.org/schema/beans/spring-beans.xsd">
  7. <bean id="hello" class="com.sywl.entity.Hello" name="hello2,hello3">
  8. <constructor-arg name="name" value="张三"/>
  9. </bean>
  10. </beans>

4.2.import配置

一般用于团队开发使用，可以将多个配置文件，导入合并为一个配置。

1. // applicationContext.xml
2. <?xml version="1.0" encoding="UTF-8"?>
3. <beans xmlns="http://www.springframework.org/schema/beans"
4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5. xsi:schemaLocation="http://www.springframework.org/schema/beans
6. https://www.springframework.org/schema/beans/spring-beans.xsd">
8. <import resource="beanUser.xml"/>
9. <import resource="beansP.xml"/>
10. <import resource="beansC.xml"/>
12. <bean id="address" class="com.sywl.entity.Address">
13. <property name="name" value="张三"/>
14. </bean>
15. </beans>

4.3scope配置（bean作用域）

1. // spring的bean作用域默认就是单例singleton
2. <bean id="hello" class="com.sywl.entity.Hello" scope="singleton">
3. <constructor-arg name="name" value="张三"/>
4. </bean>

二、IOC

1.IOC的本质

IOC是一种编程思想，由主动的编程变成被动的接收。(Inversion of Control)

• 控制：由谁控制对象的创建，传统应用程序的对象是由程序本身来控制创建的，使用了spring后，由spring来创建对象。
• 反转：程序本身不创建对象，变成现在程序被动的接收对象。
• 一句话就是：对象由spring来创建、管理、装配。

2.IOC创建对象的方式

1. 通过无参构造创建对象（默认）
2. 通过有参构造创建对象
   1. 下标赋值，下标从0开始。
      1. <bean id="hello" class="com.sywl.entity.Hello" name="hello2">
      2. <constructor-arg index="0" value="张三"/>
      3. <constructor-arg index="1" value="21"/>
      4. </bean>
   2. 通过类型创建，不建议使用。
      1. <bean id="hello" class="com.sywl.entity.Hello" name="hello2">
      2. <constructor-arg type="java.lang.String" value="张三"/>
      3. <constructor-arg type="java.lang.Integer" value="11"/>
      4. </bean>
   3. 通过参数名来设置。
      1. <bean id="hello" class="com.sywl.entity.Hello" name="hello2">
      2. <constructor-arg name="name" value="张三"/>
      3. </bean>

三、DI

1.依赖注入的几种方式

1. 构造器注入

2. set方式注入

   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. xsi:schemaLocation="http://www.springframework.org/schema/beans
   5. https://www.springframework.org/schema/beans/spring-beans.xsd">
   7. <bean id="address" class="com.sywl.entity.Address">
   8. <property name="name" value="张三"/>
   9. </bean>
   11. <bean id="student" class="com.sywl.entity.Student">
   12. <property name="name" value="张三"/>
   13. <!--注入null-->
   14. <property name="str">
   15. <null/>
   16. </property>
   18. <!--注入对象-->
   19. <property name="address" ref="address"/>
   21. <!--注入数组-->
   22. <property name="books">
   23. <array>
   24. <value>人性的弱点</value>
   25. <value>海奥华预言</value>
   26. </array>
   27. </property>
   29. <!--注入list集合-->
   30. <property name="hobbys">
   31. <list>
   32. <value>打篮球</value>
   33. <value>看书</value>
   34. <value>写字</value>
   35. </list>
   36. </property>
   38. <!--注入map集合-->
   39. <property name="card">
   40. <map>
   41. <entry key="1" value="第一个"/>
   42. <entry key="2" value="第二个"/>
   43. <entry key="3" value="第三个"/>
   44. </map>
   45. </property>
   47. <!--注入set集合-->
   48. <property name="games">
   49. <set>
   50. <value>set的第一个</value>
   51. <value>set的第二个</value>
   52. <value>set的第三个</value>
   53. </set>
   54. </property>
   56. <!--注入properties-->
   57. <property name="properties">
   58. <props>
   59. <prop key="1">爱打游戏</prop>
   60. <prop key="2">爱学习</prop>
   61. </props>
   62. </property>
   63. </bean>
   64. </beans>
3. c命名空间注入，需要有对应参数的构造器（本质构造器注入）
   1. @Data
   2. public class UserOracle {
   3. private String name;
   4. private Integer age;
   5. public UserOracle(String name, Integer age) {
   6. this.name = name;
   7. this.age = age;
   8. }
   9. }
   10. <!--c命名空间，本质是通过有参构造器来注入属性-->
   11. <bean id="userOracle" class="com.sywl.entity.UserOracle" c:name="c李白" c:age="29"/>
4. p命名空间注入，需要有属性的set方法（本质set注入）
   1. <!--p命名空间，本质是通过set方法注入属性-->
   2. <bean id="userMysql" class="com.sywl.entity.UserMySql" p:name="李白" p:age="28"/>

2.bean的作用域

1. 单例模式（spring默认机制）
   1. <bean id="hello" class="com.sywl.entity.Hello" scope="singleton">
   2. <constructor-arg name="name" value="张三"/>
   3. </bean>

2. 原型模式（每个容器中get的时候，都会产生一个新的对象）

   1. ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
   2. Hello hello = applicationContext.getBean("hello2", Hello.class);// get获取对象时。
   1. <bean id="hello" class="com.sywl.entity.Hello" scope="prototype">
   2. <constructor-arg name="name" value="张三"/>
   3. </bean>

3. 其余的request，session，application，只能在web开发中可以使用到。

3.bean的自动装配（三种装配方式）

• 自动装配式spring满足bean依赖的一种方式。
• spring会在上下文中自动寻找，并自动给bean装配属性。

1. 在xml中显式的配置。
   以上依赖注入的四种方式。
2. 在Java中显式配置。
   @Bean：装配属性
3. 隐式的自动装配bean。
   byname:会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid。（需要保证所有的bean的id唯一，并且这个bean需要和自动注入的属性set方法的值一致）
   1. <bean id="cat" class="com.sywl.entity.Cat">
   2. <property name="name" value="小猫"/>
   3. </bean>
   4. <bean id="cat" class="com.sywl.entity.Cat" autowire="byName"></bean>
   bytype:会自动在容器上下文中查找，和自己需要对象的属性类型相同的bean。（需要保证所有的bean的class唯一，并且这个bean需要和自动注入的属性的类型一致）
   1. <bean id="cat" class="com.sywl.entity.Cat">
   2. <property name="name" value="小猫"/>
   3. </bean>
   4. <bean id="cat" class="com.sywl.entity.Cat" autowire="byType"></bean>

4.隐式的注解装配bean。

• @AutoWired：默认通过byType的方式实现，而且必须要求这个对象存在！类型不唯一则通过byName
  如果AutoWired不能唯一自动装配上属性，则需要通过@Qualifier(value=”xxx”)指定名字。
• @Resource：默认通过byName的方式实现，如果找不到名字，则通过byType实现，如果两个都找不到就报错。

4.1使用步骤

1. 导入约束：context约束

2. 配置注解支持：<context:annotation-config/>

   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. https://www.springframework.org/schema/beans/spring-beans.xsd
   7. http://www.springframework.org/schema/context
   8. https://www.springframework.org/schema/context/spring-context.xsd">
   10. <!--开启注解支持-->
   11. <context:annotation-config/>
   12. </beans>

4.2注意点

• @Autowired可以在属性上使用，也可以在set方法上使用。
• 使用@Autowired我们可以不用编写set方法，前提是这个自动装配的属性在IOC容器中存在，并且符合名字byName。

四、AOP

1.代理模式好处

1. 可以使被代理对象（真实角色）的操作更加的纯粹，不用关注公共的业务。
2. 一些公共的其他业务交给代理对象，可以实现业务的分工。
3. 公共业务发生拓展的时候，方便集中的管理。
4. 一个动态代理类代理的是一个接口，一般是对应的一类业务。
5. 一个动态代理类可以代理多个类，只要实现了同一个接口即可。

2.静态代理的缺点

• 一个被代理对象就要产生一个代理对象，代码量会翻倍，开发效率会变低。

3.动态代理

1. “动态代理”被代理的角色，和”静态代理”被代理的角色一样。
2. 动态代理的类是动态生成的，不是我们直接写好的。
3. 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
   基于接口：JDK动态代理
   基于类：cglib（code generator library）
   java字节码实现：javasist
   了解两个：
   Proxy类：代理,
   InvocationHandler接口：调用处理程序

4.动态代理步骤

1. 创建真实对象。（需要被代理的对象）
   1. package com.sywl.demo04;
   2. // 基于接口：jdk动态代理
   3. public interface UserService {
   4. void create();
   5. void delete();
   6. void update();
   7. void query();
   8. }
   9. /**
   10. * 被代理对象
   11. */
   12. public class UserServiceImpl implements UserService {
   13. public void create() {
   14. System.out.println("增加");
   15. }
   16. public void delete() {
   17. System.out.println("删除");
   18. }
   19. public void update() {
   20. System.out.println("更新");
   21. }
   22. public void query() {
   23. System.out.println("查询");
   24. }
   25. }
2. 创建处理程序类ProxyInvocationHandler实现InvocationHandler接口。
   1. package com.sywl.demo04;
   2. import java.lang.reflect.InvocationHandler;
   3. import java.lang.reflect.Method;
   4. import java.lang.reflect.Proxy;
   5. /**
   6. * 这个类是"调用处理程序类"，我们会用这个类，自动生成"代理类"。（基于接口的---JDK动态代理）
   7. */
   8. public class ProxyInvocationHandler implements InvocationHandler {
   9. // 被代理的接口，通过set方法注入
   10. private Object target;
   11. public void setTarget(Object target) {
   12. this.target = target;
   13. }
   14. // 生成得到"代理类"方法
   15. public Object getProxy() {
   16. return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
   17. }
   18. // 处理"代理类"调用方法，并返回结果（当"代理类"调用方法时，方法调用将被编码并分派到"调用处理程序"的invoke方法）
   19. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   20. // 动态代理的本质，就是使用反射机制实现
   21. log(method.getName());// 其他业务操作
   22. Object result = method.invoke(target, args);// 真实角色执行的方法
   23. log("执行之后");// 其他业务操作
   24. return result;
   25. }
   26. // 添加操作日志（其他业务操作）
   27. public void log(String msg) {
   28. System.out.println("log：执行了" + msg + "方法");
   29. }
   30. }
3. 客户端调用程序。
   1. package com.sywl.demo04;
   2. public class Client {
   3. public static void main(String[] args) {
   4. // 被代理对象（真实角色）
   5. UserServiceImpl userServiceImpl = new UserServiceImpl();
   6. // 创建"调用处理程序对象"。代理对象：现在没有
   7. ProxyInvocationHandler pih = new ProxyInvocationHandler();
   8. // 通过"调用处理程序"处理"被代理对象（真实角色）"，来处理我们要调用的接口对象
   9. // set方法设置属性参数
   10. pih.setTarget(userServiceImpl);
   11. // 获得"代理类"
   12. UserService proxy = (UserService) pih.getProxy();
   13. // "代理类"执行方法。此时的方法调用将被编码并分派到"调用处理程序"的invoke方法
   14. proxy.create();
   15. System.out.println();
   16. proxy.delete();
   17. System.out.println();
   18. proxy.update();
   19. System.out.println();
   20. proxy.query();
   21. }
   22. }

5.AOP概念(Aspect Oriented Programming)

• 面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
• AOP是OOP的延续，利用AOP可以对业务逻辑的各个部分进行隔离，从而降低业务逻辑的耦合性，
• 提高程序可重用性，同时提高开发的效率。

6.AOP作用

• 横切关注点：跨越应用程序多个模块的方法或功能。（与我们业务逻辑无关，但需要我们关注的部分就是横切关注点。例如：日志、缓存、安全、事务等等）
• 切面（Aspect）：横切关注点被模块化的特殊对象。它是一个类
• 通知（Advice）：切面必须要完成的工作。它是类中的一个方法
• 目标（Target）：被通知的对象。它是一个接口或方法
• 代理（Proxy）：向目标对象应用通知之后创建的对象。它是代理类
• 切入点（PointCut）：切面通知执行的“地点”的定义。（连接点和切入点就是在哪个地方执行，即invoke方法执行的地方）
• 连接点（JointPoint）：与切入点匹配的执行点。

7.AOP实现方式一（原生Spring API接口）

1. 导入spring包，aop包。
   1. <!--spring-->
   2. <dependency>
   3. <groupId>org.springframework</groupId>
   4. <artifactId>spring-webmvc</artifactId>
   5. <version>5.2.0.RELEASE</version>
   6. </dependency>
   7. <!--aop-->
   8. <dependency>
   9. <groupId>org.aspectj</groupId>
   10. <artifactId>aspectjweaver</artifactId>
   11. <version>1.9.4</version>
   12. </dependency>
2. 被通知的对象，相当于被代理对象。
   1. // 接口
   2. package com.sywl.service;
   3. public interface UserService {
   4. void create();
   5. void delete();
   6. void update();
   7. void query();
   8. }
   9. // 实现类
   10. package com.sywl.service;
   11. public class UserServiceImpl implements UserService {
   12. public void create() {
   13. System.out.println("执行了create方法");
   14. }
   15. public void delete() {
   16. System.out.println("执行了delete方法");
   17. }
   18. public void update() {
   19. System.out.println("执行了update方法");
   20. }
   21. public void query() {
   22. System.out.println("执行了query方法");
   23. }
   24. }
3. 创建前置通知类，后置通知类。
   1. // 前置通知类
   2. package com.sywl.log;
   3. import org.springframework.aop.MethodBeforeAdvice;
   4. import java.lang.reflect.Method;
   5. public class BeforeLog implements MethodBeforeAdvice {
   6. /**
   7. * @param method：要执行的目标对象的方法
   8. * @param args：参数
   9. * @param target：目标对象
   10. * @throws Throwable
   11. */
   12. public void before(Method method, Object[] args, Object target) throws Throwable {
   13. System.out.println(target.getClass().getName() + "的" + method.getName() + "方法被执行了");
   14. }
   15. }
   16. // 后置通知类
   17. package com.sywl.log;
   18. import org.springframework.aop.AfterReturningAdvice;
   19. import java.lang.reflect.Method;
   20. public class AfterLog implements AfterReturningAdvice {
   21. /**
   22. * @param returnValue：返回值
   23. * @param method
   24. * @param args
   25. * @param target
   26. * @throws Throwable
   27. */
   28. public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
   29. System.out.println("执行了" + method.getName() + "方法，返回结果为：" + returnValue);
   30. }
   31. }

4. spring配置aop

   1. // ApplicationContext.xml
   2. <?xml version="1.0" encoding="UTF-8"?>
   3. <beans xmlns="http://www.springframework.org/schema/beans"
   4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   5. xmlns:aop="http://www.springframework.org/schema/aop"
   6. xsi:schemaLocation="http://www.springframework.org/schema/beans
   7. https://www.springframework.org/schema/beans/spring-beans.xsd
   8. http://www.springframework.org/schema/aop
   9. https://www.springframework.org/schema/aop/spring-aop.xsd">
   11. <!--注册bean-->
   12. <bean id="userService" class="com.sywl.service.UserServiceImpl"/>
   13. <bean id="beforeLog" class="com.sywl.log.BeforeLog"/>
   14. <bean id="afterLog" class="com.sywl.log.AfterLog"/>
   16. <!--方式一：使用原生Spring API接口-->
   17. <!--配置aop：需要导入aop的约束-->
   18. <aop:config>
   19. <!--配置切入点：expression表达式，execution(要执行的位置！ * * * * *)-->
   20. <aop:pointcut id="pointcut" expression="execution(* com.sywl.service.UserServiceImpl.*(..))"/>
   21. <!--执行环绕增强！-->
   22. <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
   23. <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
   24. </aop:config>
   25. </beans>
5. 执行。
   1. import com.sywl.service.UserService;
   2. import org.springframework.context.ApplicationContext;
   3. import org.springframework.context.support.ClassPathXmlApplicationContext;
   4. public class MyTest01 {
   5. public static void main(String[] args) {
   6. ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
   7. // 动态代理的是接口：注意点
   8. UserService userService = context.getBean("userService", UserService.class);
   9. userService.create();
   10. }
   11. }

8.AOP实现方式二（自定义类）

1. 导入spring包，aop包。
2. 被通知的对象，相当于被代理对象。
3. 自定义通知类
   1. package com.sywl.diy;
   2. public class DiyPointCut {
   3. public void before(){
   4. System.out.println("-------方法执行前--------");
   5. }
   6. public void after(){
   7. System.out.println("-------方法执行后--------");
   8. }
   9. }

4. spring配置aop

   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:aop="http://www.springframework.org/schema/aop"
   5. xsi:schemaLocation="http://www.springframework.org/schema/beans
   6. https://www.springframework.org/schema/beans/spring-beans.xsd
   7. http://www.springframework.org/schema/aop
   8. https://www.springframework.org/schema/aop/spring-aop.xsd">
   10. <!--方式二：自定义类-->
   11. <bean id="diy" class="com.sywl.diy.DiyPointCut"/>
   12. <aop:config>
   13. <!--自定义切面，ref要引用的类-->
   14. <aop:aspect ref="diy">
   15. <!--切入点-->
   16. <aop:pointcut id="point" expression="execution(* com.sywl.service.UserServiceImpl.*(..))"/>
   17. <!--通知-->
   18. <aop:before method="before" pointcut-ref="point"/>
   19. <aop:after method="after" pointcut-ref="point"/>
   20. </aop:aspect>
   21. </aop:config>
   22. </beans>
5. 执行。

9.AOP实现方式三（注解）

1. 导入spring包，aop包。
2. 被通知的对象，相当于被代理对象。

3. 自定义通知类。使用注解标注。

   1. package com.sywl.diy;
   2. import org.aspectj.lang.ProceedingJoinPoint;
   3. import org.aspectj.lang.annotation.After;
   4. import org.aspectj.lang.annotation.Around;
   5. import org.aspectj.lang.annotation.Aspect;
   6. import org.aspectj.lang.annotation.Before;
   7. /**
   8. * 方式三：使用注解的方式实现AOP
   9. */
   10. @Aspect // 标注这个类是一个切面
   11. public class AnnotationPointCut {
   13. @Before("execution(* com.sywl.service.UserServiceImpl.*(..))")
   14. public void before(){
   15. System.out.println("-------方法执行前--------");
   16. }
   18. @After("execution(* com.sywl.service.UserServiceImpl.*(..))")
   19. public void after(){
   20. System.out.println("-------方法执行后--------");
   21. }
   23. // 在环绕增加中，我们可以给定一个参数，代表我们要处理切入的点
   24. @Around("execution(* com.sywl.service.UserServiceImpl.*(..))")
   25. public void around(ProceedingJoinPoint joinPoint) throws Throwable {
   26. System.out.println("环绕前");
   28. // 执行方法
   29. Object proceed = joinPoint.proceed();
   30. System.out.println("环绕后");
   31. }
   32. }

4. spring配置aop

   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:aop="http://www.springframework.org/schema/aop"
   5. xsi:schemaLocation="http://www.springframework.org/schema/beans
   6. https://www.springframework.org/schema/beans/spring-beans.xsd
   7. http://www.springframework.org/schema/aop
   8. https://www.springframework.org/schema/aop/spring-aop.xsd">
   10. <!--方式三：注解方式实现aop-->
   11. <bean id="annotationPointCut" class="com.sywl.diy.AnnotationPointCut"/>
   12. <!--开启注解支持：JDK（默认） cglib-->
   13. <aop:aspectj-autoproxy proxy-target-class="false"/><!--默认是flase,true时是cglib-->
   14. </beans>
5. 执行。

五、spring注解开发

1.解决问题：

bean即@Component，属性注入@Value，衍生的注解@Controller、@Service、@Repository，自动装配@Autowired和@Resource，作用域@Scope。

• @Component、@Controller、@Service、@Repository这四个注解功能都是一样，代表将某个类注册到spring中，这个类被spring管理了，就是bean

• 注解开发的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. https://www.springframework.org/schema/beans/spring-beans.xsd
  7. http://www.springframework.org/schema/context
  8. https://www.springframework.org/schema/context/spring-context.xsd">
  10. <!--开启注解支持-->
  11. <context:annotation-config/>
  12. <!--扫描注解的包-->
  13. <context:component-scan base-package="com.sywl.entity"/>
  14. </beans>
• 实体类User
  1. package com.sywl.entity;
  2. import org.springframework.beans.factory.annotation.Value;
  3. import org.springframework.context.annotation.Scope;
  4. import org.springframework.stereotype.Component;
  5. //@Component等价于<bean id="user" class="com.sywl.entity.User"/>
  6. @Component
  7. @Scope("singleton")
  8. public class User {
  9. // @Value("张三")等价于<property name="name" value="张三"/>
  10. @Value("张三")
  11. private String name;
  12. public String getName() {
  13. return name;
  14. }
  15. public void setName(String name) {
  16. this.name = name;
  17. }
  18. }

2.小结

• xml更加万能，适用于任何场合；维护简单方便。
• 注解不是自己类不能使用，维护相对复杂。
• 建议：xml用来管理bean；注解只负责完成属性的注入；使用时需要让注解生效，开启注解支持。
  1. <!--开启注解支持-->
  2. <context:annotation-config/>
  3. <!--扫描注解的包-->
  4. <context:component-scan base-package="com.sywl.entity"/>

五、spring的Javaconfig

• Java来配置文件

  1. package com.sywl.config;
  2. import com.sywl.entity.User;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.ComponentScan;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.context.annotation.Import;
  7. // configuration也会被spring容器管理，注册到容器中，本来就是一个@Componet
  8. // @Configuration代表这个一个配置类，就是我们之前看到的beans.xml
  9. @Configuration
  10. @ComponentScan("com.sywl.entity")
  11. @Import(SywlConfig2.class)
  12. public class SywlConfig {
  14. // 注册一个bean，就是我们之前在beans.xml中写的bean标签
  15. // 这个方法的名字，相当于bean标签的id属性
  16. // 返回值相当于bean标签的class属性
  17. @Bean
  18. public User user(){
  19. return new User();
  20. }
  21. }
• Java来配置文件使用了@Configuration
  1. import com.sywl.config.SywlConfig;
  2. import com.sywl.entity.User;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  5. public class MyTest01 {
  6. public static void main(String[] args) {
  7. // 通过AnnotationConfig上下文来获取容器，通过配置类的class对象加载
  8. ApplicationContext context = new AnnotationConfigApplicationContext(SywlConfig.class);
  9. User user = context.getBean("user", User.class);
  10. System.out.println(user.getName());
  11. }
  12. }

六、spring整合mybatis

1.整合需要导入的依赖包。

• junit
• mybatis
• mysql
• spring
• aop
• mybatis-spring（spring和mybatis的整合包）
• 需要注意依赖包的版本问题
  1. <dependency>
  2. <groupId>junit</groupId>
  3. <artifactId>junit</artifactId>
  4. <version>4.12</version>
  5. <scope>test</scope>
  6. </dependency>
  7. <dependency>
  8. <groupId>mysql</groupId>
  9. <artifactId>mysql-connector-java</artifactId>
  10. <version>5.1.26</version>
  11. </dependency>
  12. <dependency>
  13. <groupId>org.mybatis</groupId>
  14. <artifactId>mybatis</artifactId>
  15. <version>3.5.2</version>
  16. </dependency>
  17. <dependency>
  18. <groupId>org.springframework</groupId>
  19. <artifactId>spring-webmvc</artifactId>
  20. <version>5.2.6.RELEASE</version>
  21. </dependency>
  22. <!--spring操作数据库，还需要spring-jdbc-->
  23. <dependency>
  24. <groupId>org.springframework</groupId>
  25. <artifactId>spring-jdbc</artifactId>
  26. <version>5.2.0.RELEASE</version>
  27. </dependency>
  28. <dependency>
  29. <groupId>org.aspectj</groupId>
  30. <artifactId>aspectjweaver</artifactId>
  31. <version>1.9.6</version>
  32. </dependency>
  33. <dependency>
  34. <groupId>org.mybatis</groupId>
  35. <artifactId>mybatis-spring</artifactId>
  36. <version>2.0.2</version>
  37. </dependency>
  38. <dependency>
  39. <groupId>org.projectlombok</groupId>
  40. <artifactId>lombok</artifactId>
  41. <version>1.18.12</version>
  42. </dependency>

2.spring整合mybatis方式一

1. 配置核心文件。（编写数据源，配置SqlSessionFactory，配置SqlSessionTemplate）

   1. // 主配置文件applicationContext.xml；可以把整合mybatis的spring-dao.xml导入到主配置文件。
   2. <?xml version="1.0" encoding="UTF-8"?>
   3. <beans xmlns="http://www.springframework.org/schema/beans"
   4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   5. xmlns:aop="http://www.springframework.org/schema/aop"
   6. xsi:schemaLocation="http://www.springframework.org/schema/beans
   7. https://www.springframework.org/schema/beans/spring-beans.xsd
   8. http://www.springframework.org/schema/aop
   9. https://www.springframework.org/schema/aop/spring-aop.xsd">
   11. <import resource="spring-dao.xml"/>
   13. <!--第一种方式把sqlSessionTemplate注入到实现类中。第二种方式，可以省略这一步-->
   14. <bean id="userMapper" class="com.sywl.mapper.UserMapperImpl">
   15. <property name="sqlSessionTemplate" ref="sqlSession"/>
   16. </bean>
   17. </beans>
   1. // spring-dao.xml
   2. <?xml version="1.0" encoding="UTF-8"?>
   3. <beans xmlns="http://www.springframework.org/schema/beans"
   4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   5. xmlns:aop="http://www.springframework.org/schema/aop"
   6. xsi:schemaLocation="http://www.springframework.org/schema/beans
   7. https://www.springframework.org/schema/beans/spring-beans.xsd
   8. http://www.springframework.org/schema/aop
   9. https://www.springframework.org/schema/aop/spring-aop.xsd">
   11. <!--DataSource：使用spring的数据源替换Mybatis的配置。 c3p0 dbcp druid
   12. 我们这里使用spring提供的JDBC：org.springframework.jdbc.datasource
   13. -->
   14. <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
   15. <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
   16. <property name="url" value="jdbc:mysql://localhost:3306/z_mybatis?useUnicode=true&amp;characterEncoding=UTF-8"/>
   17. <property name="username" value="root"/>
   18. <property name="password" value="xxx"/>
   19. </bean>
   21. <!--sqlSessionFactory：注入数据源，可以绑定mybatis配置文件-->
   22. <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
   23. <property name="dataSource" ref="dataSource" />
   24. <!--绑定mybatis配置文件：绑定后，mybatis中的配置可以省略-->
   25. <property name="configLocation" value="classpath:mybatis-config.xml"/>
   26. <property name="mapperLocations" value="classpath:com/sywl/mapper/*.xml"/>
   27. </bean>
   29. <!--SqlSessionTemplate：就是我们使用的sqlSession，注入sqlSessionFactory-->
   30. <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
   31. <!--只能使用构造器注入sqlSessionFactory，因为它没有set方法-->
   32. <constructor-arg index="0" ref="sqlSessionFactory"/>
   33. </bean>
   34. </beans>
   1. // 一般保留mybatis-config.xml文件。（只配置别名和设置）
   2. <?xml version="1.0" encoding="UTF-8" ?>
   3. <!DOCTYPE configuration
   4. PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
   5. "http://mybatis.org/dtd/mybatis-3-config.dtd">
   6. <configuration>
   8. <typeAliases>
   9. <package name="com.sywl.entity"/>
   10. </typeAliases>
   12. <!--<settings>
   13. <setting name="" value=""/>
   14. </settings>-->
   15. </configuration>
2. 需要给接口加实现类。
   1. package com.sywl.mapper;
   2. import com.sywl.entity.User01;
   3. import org.mybatis.spring.SqlSessionTemplate;
   4. import java.util.List;
   5. /**
   6. * 方式一：spring接管mybatis时，需要多这个实现类。
   7. */
   8. public class UserMapperImpl implements UserMapper {
   9. // 我们所有操作，都使用sqlSession来执行。现在都使用SqlSessionTemplate
   10. // 在applicationContext.xml文件中注入sqlSessionTemplate
   11. private SqlSessionTemplate sqlSessionTemplate;
   12. public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
   13. this.sqlSessionTemplate = sqlSessionTemplate;
   14. }
   15. public List<User01> selectUsers() {
   16. UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
   17. return mapper.selectUsers();
   18. }
   19. }

3. 将自己写的实现类注入到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:aop="http://www.springframework.org/schema/aop"
   5. xsi:schemaLocation="http://www.springframework.org/schema/beans
   6. https://www.springframework.org/schema/beans/spring-beans.xsd
   7. http://www.springframework.org/schema/aop
   8. https://www.springframework.org/schema/aop/spring-aop.xsd">
   10. <import resource="spring-dao.xml"/>
   12. <!--第一种方式把sqlSessionTemplate注入到实现类中。第二种方式，可以省略这一步-->
   13. <bean id="userMapper" class="com.sywl.mapper.UserMapperImpl">
   14. <property name="sqlSessionTemplate" ref="sqlSession"/>
   15. </bean>
   16. </beans>
4. 测试使用。
   1. @Test
   2. public void test(){
   3. ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
   4. UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
   5. List<User01> user01s = userMapper.selectUsers();
   6. for (User01 user01 : user01s) {
   7. System.out.println(user01);
   8. }
   9. }

2.spring整合mybatis方式二

1. 配置核心文件。（编写数据源，配置SqlSessionFactory，配置SqlSessionTemplate）

   1. // 主配置文件applicationContext.xml；可以把整合mybatis的spring-dao.xml导入到主配置文件。
   2. <?xml version="1.0" encoding="UTF-8"?>
   3. <beans xmlns="http://www.springframework.org/schema/beans"
   4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   5. xmlns:aop="http://www.springframework.org/schema/aop"
   6. xsi:schemaLocation="http://www.springframework.org/schema/beans
   7. https://www.springframework.org/schema/beans/spring-beans.xsd
   8. http://www.springframework.org/schema/aop
   9. https://www.springframework.org/schema/aop/spring-aop.xsd">
   11. <import resource="spring-dao.xml"/>
   13. <!--第二种方式加上这一步-->
   14. <bean id="userMapper2" class="com.sywl.mapper.UserMapperImpl2">
   15. <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
   16. </bean>
   17. </beans>
   1. // spring-dao.xml
   2. <?xml version="1.0" encoding="UTF-8"?>
   3. <beans xmlns="http://www.springframework.org/schema/beans"
   4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   5. xmlns:aop="http://www.springframework.org/schema/aop"
   6. xsi:schemaLocation="http://www.springframework.org/schema/beans
   7. https://www.springframework.org/schema/beans/spring-beans.xsd
   8. http://www.springframework.org/schema/aop
   9. https://www.springframework.org/schema/aop/spring-aop.xsd">
   11. <!--DataSource：使用spring的数据源替换Mybatis的配置。 c3p0 dbcp druid
   12. 我们这里使用spring提供的JDBC：org.springframework.jdbc.datasource
   13. -->
   14. <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
   15. <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
   16. <property name="url" value="jdbc:mysql://localhost:3306/z_mybatis?useUnicode=true&amp;characterEncoding=UTF-8"/>
   17. <property name="username" value="root"/>
   18. <property name="password" value="xxx"/>
   19. </bean>
   21. <!--sqlSessionFactory：注入数据源，可以绑定mybatis配置文件-->
   22. <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
   23. <property name="dataSource" ref="dataSource" />
   24. <!--绑定mybatis配置文件：绑定后，mybatis中的配置可以省略-->
   25. <property name="configLocation" value="classpath:mybatis-config.xml"/>
   26. <property name="mapperLocations" value="classpath:com/sywl/mapper/*.xml"/>
   27. </bean>
   29. <!--SqlSessionTemplate：就是我们使用的sqlSession，注入sqlSessionFactory-->
   30. <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
   31. <!--只能使用构造器注入sqlSessionFactory，因为它没有set方法-->
   32. <constructor-arg index="0" ref="sqlSessionFactory"/>
   33. </bean>
   34. </beans>
   1. // 一般保留mybatis-config.xml文件。（只配置别名和设置）
   2. <?xml version="1.0" encoding="UTF-8" ?>
   3. <!DOCTYPE configuration
   4. PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
   5. "http://mybatis.org/dtd/mybatis-3-config.dtd">
   6. <configuration>
   8. <typeAliases>
   9. <package name="com.sywl.entity"/>
   10. </typeAliases>
   12. <!--<settings>
   13. <setting name="" value=""/>
   14. </settings>-->
   15. </configuration>
2. 需要给接口加实现类。
   1. package com.sywl.mapper;
   2. import com.sywl.entity.User01;
   3. import org.mybatis.spring.support.SqlSessionDaoSupport;
   4. import java.util.List;
   5. /**
   6. * 第二种方式：可以继承SqlSessionDaoSupport直接获取sqlSession。不需要注入SqlSessionTemplate属性。
   7. * spring接管mybatis时，需要多这个实现类
   8. */
   9. public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
   10. public List<User01> selectUsers() {
   11. return getSqlSession().getMapper(UserMapper.class).selectUsers();
   12. }
   13. }

3. 将自己写的实现类注入到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:aop="http://www.springframework.org/schema/aop"
   5. xsi:schemaLocation="http://www.springframework.org/schema/beans
   6. https://www.springframework.org/schema/beans/spring-beans.xsd
   7. http://www.springframework.org/schema/aop
   8. https://www.springframework.org/schema/aop/spring-aop.xsd">
   10. <import resource="spring-dao.xml"/>
   12. <!--第二种方式加上这一步-->
   13. <bean id="userMapper2" class="com.sywl.mapper.UserMapperImpl2">
   14. <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
   15. </bean>
   16. </beans>
4. 测试使用。
   1. @Test
   2. public void test(){
   3. ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
   4. UserMapper userMapper = context.getBean("userMapper2", UserMapper.class);
   5. List<User01> user01s = userMapper.selectUsers();
   6. for (User01 user01 : user01s) {
   7. System.out.println(user01);
   8. }
   9. }

七、spring中的事务

1.声明式事务(aop)

1. // spring-dao.xml
2. <?xml version="1.0" encoding="UTF-8"?>
3. <beans xmlns="http://www.springframework.org/schema/beans"
4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5. xmlns:aop="http://www.springframework.org/schema/aop"
6. xmlns:tx="http://www.springframework.org/schema/tx"
7. xsi:schemaLocation="http://www.springframework.org/schema/beans
8. https://www.springframework.org/schema/beans/spring-beans.xsd
9. http://www.springframework.org/schema/aop
10. https://www.springframework.org/schema/aop/spring-aop.xsd
11. http://www.springframework.org/schema/tx
12. https://www.springframework.org/schema/tx/spring-tx.xsd">
14. <!--DataSource：使用spring的数据源替换Mybatis的配置 c3p0 dbcp druid
15. 我们这里使用spring提供的JDBC：org.springframework.jdbc.datasource
16. -->
17. <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
18. <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
19. <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
20. <property name="username" value="root"/>
21. <property name="password" value="xxx"/>
22. </bean>
24. <!--sqlSessionFactory：注入数据源，可以绑定mybatis配置文件-->
25. <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
26. <property name="dataSource" ref="dataSource" />
27. <!--绑定mybatis配置文件：绑定后，mybatis中的配置可以省略-->
28. <property name="configLocation" value="classpath:mybatis-config.xml"/>
29. <property name="mapperLocations" value="classpath:com/sywl/mapper/*.xml"/>
30. </bean>
32. <!--SqlSessionTemplate：就是我们使用的sqlSession，注入sqlSessionFactory-->
33. <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
34. <!--只能使用构造器注入sqlSessionFactory，因为它没有set方法-->
35. <constructor-arg index="0" ref="sqlSessionFactory"/>
36. </bean>
38. <!--配置声明式事务-->
39. <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
40. <constructor-arg ref="dataSource" />
41. </bean>
43. <!--结合AOP实现事物的织入-->
44. <!--配置事务通知：通知就是一个方法-->
45. <tx:advice id="txAdvice" transaction-manager="transactionManager">
46. <!--给哪些方法配置事务-->
47. <!--给事务配置传播特性-->
48. <tx:attributes>
49. <!--*代表所用方法。以add、delete、update、query开头的方法配置事务。（可以单独配置，也可以配置全部方法）-->
50. <tx:method name="*" propagation="REQUIRED"/>
51. <tx:method name="add" propagation="REQUIRED"/>
52. <tx:method name="delete" propagation="REQUIRED"/>
53. <tx:method name="update" propagation="REQUIRED"/>
54. <tx:method name="query" propagation="REQUIRED"/>
55. </tx:attributes>
56. </tx:advice>
58. <!--配置事务切入-->
59. <aop:config>
60. <!--配置切入点："切入点"就是"通知"执行的地点。目前配置的地点是com.sywl.mapper包下的所有方法-->
61. <aop:pointcut id="txPointCut" expression="execution(* com.sywl.mapper.*.*(..))"/>
62. <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
63. </aop:config>
64. </beans>

2.编程式事务

需要在代码中进行事务的管理

总结

掌握IOC和AOP的概念
需要搞懂动态代理的原理
掌握spring的事务管理