北京动力节点-Spring4讲义-第4章Spring与DAO

合集下载

Spring基础教程

Spring 快速入门教程──开发你的第一个Spring程序翻译整理：Hantsy Bai<hantsy@>本章学习用struts MVC框架作前端，Spring做中间层，Hibernate作后端来开发一个简单的Spring应用程序。

在第4章将使用Spring MVC框架对它进行重构。

本章包含以下内容：编写功能性测试。

配置Hibernate和Transaction。

载入Spring的applicationContext.xml文件。

设置业务代理(business delegates)和DAO的依赖性。

把spring写入Struts 程序。

概述你将会创建一个简单的程序完成最基本的CRUD(Create, Retrieve, Update和 Delete)操作。

这个程序叫MyUsers，作为本书的样例。

这是一个3层架构的web程序，通过一个Action 来调用业务代理，再通过它来回调 DAO类。

下面的流程图表示了MyUsers是如何工作的。

数字表明了流程的先后顺序，从web层(UserAction)到中间层(UserManager)，再到数据层(UserDAO)，然后返回。

鉴于大多数读者都比较熟悉struts，本程序采用它作为MVC 框架。

Spring的魅力在于它宣称式的事务处理，依懒性的绑定和持久性的支持。

第4 章中将用 Spring框架对它进行重构。

接下来你会进行以下几个步骤：1.下载Struts和Spring。

2.创建项目目录和ant Build文件。

3.为持久层创建一个单元测试(unit tests)。

4.配置Hibernate和Spring。

5.编写HIbernate DAO的实现。

6.进行单元测试，通过DAO验证CRUD。

7.创建一个Manager来声明事务处理。

8.为struts Action 编写测试程序。

9.为web层创建一个Action 和model(DynaActionForm)。

Spring4基本使用

Spring4基本使⽤前⾔虽然现在基本上是 springboot 的天下了，但是传统的 spring4 在⼴⼤的软件企业中仍然占据很⼤⽐例。

⼀上⼿能⽤，但是要让我从⽆到有搭⼀个spring4的开发环境出来，可能会磕磕碰碰，耽误不少时间，所以这⾥从⽆到有搭⼀个 spring4的开发环境出来，⼀步步完善，也复习下 spring 的基本⽤法，温故知新。

创建maven项⽬，引⼊spring4的⼀些核⼼包和常⽤扩展包。

我⽤的是spring4最新版本4.3.24.RELEASEpom.xmlxml version="1.0" encoding="UTF-8"><project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.hz</groupId><artifactId>admin</artifactId><version>1.0-SNAPSHOT</version><packaging>war</packaging><name>admin Maven Webapp</name><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><piler.source>1.8</piler.source><piler.target>1.8</piler.target><spring.version>4.3.24.RELEASE</spring.version><junit.version>4.11</junit.version><jackson.version>2.9.8</jackson.version></properties><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>${junit.version}</version><scope>test</scope></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context-support</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-aspects</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-tx</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-web</artifactId><version>${spring.version}</version><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>${jackson.version}</version></dependency><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-core</artifactId><version>${jackson.version}</version></dependency><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-annotations</artifactId><version>${jackson.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>${spring.version}</version></dependency></dependencies><build><finalName>admin</finalName><pluginManagement><plugins><plugin><artifactId>maven-clean-plugin</artifactId><version>3.1.0</version></plugin><plugin><artifactId>maven-resources-plugin</artifactId><version>3.0.2</version></plugin><plugin><artifactId>maven-compiler-plugin</artifactId><version>3.8.0</version><configuration><source>${piler.source}</source><target>${piler.target}</target></configuration></plugin><plugin><artifactId>maven-surefire-plugin</artifactId><version>2.22.1</version></plugin><plugin><artifactId>maven-war-plugin</artifactId><version>3.2.2</version></plugin><plugin><artifactId>maven-install-plugin</artifactId><version>2.5.2</version></plugin><plugin><artifactId>maven-deploy-plugin</artifactId><version>2.8.2</version></plugin><plugin><groupId>org.eclipse.jetty</groupId><artifactId>jetty-maven-plugin</artifactId><version>9.4.18.v20190429</version><configuration><httpConnector><port>8082</port> </httpConnector><scanIntervalSeconds>2</scanIntervalSeconds><webApp><contextPath>/</contextPath></webApp></configuration></plugin></plugins></pluginManagement></build></project>配置web.xmlweb.xml⽂件是web项⽬的启动⽂件，要想在web项⽬中使⽤spring，需要在这⾥配置spring<!DOCTYPE web-app PUBLIC"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN""/dtd/web-app_2_3.dtd" ><web-app><display-name>Archetype Created Web Application</display-name><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:/spring.xml</param-value> <listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><servlet><servlet-name>dispatcher</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:/spring/spring-mvc.xml</param-value>  </init-param><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>dispatcher</servlet-name><url-pattern>/</url-pattern></servlet-mapping><welcome-file-list><welcome-file>login.html</welcome-file></welcome-file-list><error-page> <error-code>404</error-code><location>/nopage.html</location></error-page><error-page> <exception-type>ng.NullPointerException</exception-type><location>/error.html</location></error-page><session-config><session-timeout>360</session-timeout></session-config></web-app>配置mvcspring-mvc.xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:mvc="/schema/mvc"xmlns:p="/schema/p"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd/schema/context /schema/context/spring-context-4.1.xsd/schema/mvc /schema/mvc/spring-mvc-4.1.xsd"><context:component-scan base-package="com.hz.*.controller"/><mvc:default-servlet-handler /><mvc:annotation-driven /><bean id="mappingJacksonHttpMessageConverter"class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"><property name="supportedMediaTypes"><list><value>text/html;charset=UTF-8</value></list></property></bean><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"id="internalResourceViewResolver"><property name="prefix" value="/WEB-INF/page/" /><property name="suffix" value=".jsp" /></bean></beans>项⽬结构测试Controllerpackage mon.controller;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;import java.util.HashMap;import java.util.Map;@Controller()@RequestMapping("test")public class TestController {@RequestMapping("/info")@ResponseBodypublic Object test(Integer val){// contentType=application/x-www-form-urlencoded System.out.println(val == null ? "null" : val.toString()); HashMap<String, Object> map = new HashMap<>(); map.put("prop", "value");map.put("prop1", "value1");return map;}}postman测试。

北京动力节点-Spring4讲义-第2章Spring与IoC

第2章Spring与IoC控制反转（IOC，Inversion of Control），是一个概念，是一种思想。

指将传统上由程序代码直接操控的对象调用权交给容器，通过容器来实现对象的装配和管理。

控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。

IoC是一个概念，是一种思想，其实现方式多种多样。

当前比较流行的实现方式有两种：依赖注入和依赖查找。

依赖注入方式应用更为广泛。

依赖查找：Dependency Lookup，DL，容器提供回调接口和上下文环境给组件，程序代码则需要提供具体的查找方式。

比较典型的是依赖于JNDI服务接口（Java Naming and Directory Interface）的查找。

依赖注入：Dependency Injection，DI，程序代码不做定位查询，这些工作由容器自行完成。

依赖注入DI是指程序运行过程中，若需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部容器，由外部容器创建后传递给程序。

Spring的依赖注入对调用者与被调用者几乎没有任何要求，完全支持POJO之间依赖关系的管理。

依赖注入是目前最优秀的解耦方式。

依赖注入让Spring的Bean之间以配置文件的方式组织在一起，而不是以硬编码的方式耦合在一起的。

2.1 Spring程序开发在普通三层架构的基础上，将程序修改为Spring框架程序举例：springDemo2.1.1 导入Jar包首先，导入Spring程序开发的四个基本jar包。

其次，导入日志相关的Jar包。

在依赖库spring-framework-3.0.2.RELEASE-dependencies.zip解压目录下：\mons\mons.logging\1.1.1下的mons.logging-1.1.1.jar 文件。

该文件只是日志记录的实现规范，并没有具体的实现。

相当于slf4j.jar 的作用。

这里日志的实现使用log4j ，故还需要log4j.jar 。

Java Spring学习路线

路线
Java Spring 学习路线 ........................................................................................................................................ 1 Spring 的概述 ............................................................................................................................................. 4 什么是 Spring.................................................................................................................................... 4 为什么学习 Spring........................................................................................................................... 5 Spring 的版本.................................................................................................................................... 5 Spring 的入门（IOC） .................................................

Spring知识点详解

Spring知识点详解⼀：概述⼀、简介1. 概念1. Spring是⼀个轻量级的控制反转(IoC)和⾯向切⾯(AOP)的开源容器框架，它由创建。

2. Spring致⼒于提供⼀个以统⼀的、⾼效的⽅式构造整个应⽤，并且可以将单层框架以最佳的组合揉和在⼀起建⽴⼀个连贯的体系。

2. 作⽤：解决企业应⽤开发的复杂性3. 特点1. ⽅便解耦，简化开发：管理所有对象的创建和依赖的关系维护。

2. AOP编程的⽀持：⽅便的实现对程序进⾏权限拦截、运⾏监控等功能。

3. 声明式事务的⽀持：通过配置完成对事务的管理，⽽⽆需⼿动编程。

4. ⽅便程序的测试：Spring对Junit4⽀持，可以通过注解⽅便的测试Spring程序。

5. ⽅便集成各种优秀框架：内部提供了对各种优秀框架的直接⽀持。

6. 降低JavaEE API的使⽤难度：封装JavaEE开发中⾮常难⽤的⼀些API（JDBC、JavaMail、远程调⽤等）。

⼆、体系结构1. 核⼼容器（Core Container）1. Spring-core模块：提供了框架的基本组成部分，包括控制反转（IOC）和依赖注⼊（DI）功能。

2. Spring-beans模块：提供了BeanFactory与Bean的装配，使Spring成为⼀个容器。

3. Spring-context模块：应⽤上下⽂，建⽴在1和2基础之上，提供⼀个框架式的对象访问⽅式，是访问定义和配置任何对象的媒介，使Spring成为⼀个框架。

4. Spring-context-support模块：⽀持整合第三⽅库到Spring应⽤程序上下⽂，特别是⽤于⾼速缓存（EhCache、JCache）和任务调度（CommonJ、Quartz）的⽀持。

4. Spring-expression模块：提供了强⼤的表达式语⾔(扩展的EL)去⽀持运⾏时查询和操作对象图。

2. 中间层1. Spring-aop模块：提供了⼀个符合AOP要求的⾯向切⾯的编程实现，允许定义⽅法拦截器和切⼊点，将代码按照功能进⾏分离，以便⼲净地解耦。

Spring Framework 4 Part I. Spring 框架概述中文

图 2.1. Spring 框架概述
2.2.1 核心容器 Core Container
核心容器包含 Core, Beans, Context( 上下文 ), and Expression Language modules（表达式语言模块）.
包括 IoC 和 Dependency Core 和 Bean 模块提供基本部分的框架， Injection 功能。BeanFactorys 是一个工厂模式的经典实现。它不需要可编程单例，并且允许你从你的实际程序逻辑解耦配置和规范依赖关系。上下文模块建立在 Core 和 Bean 模块建立的坚实基础上：它是在类似于 JNDI 注册的框架式的方式访问对象的一种手段。上下文模块从 Beans 模块继承其功能和添加了对国际化 internationalization ( 使用 using, 例如 for example, 资源包 resource bundles), 事件传播 event-propagation, 资源装载 resource-loading 和透明的创建上下文 , 例如 , 一个 servlet 容器。上下文模块也支持 Java EE 的功能，比如说 EJB、JMX 和基本的远程访问。ApplicationContext 接口是上下文模块的焦点。表达式语言模块提供了一个在运行时查询和操纵对象图的强大的表达式语言。它是在 JSP 2.1规范中指定的统一表达式语言（统一 EL）的一个扩展。语言支持设置和获取属性值，属性赋值，方法调用，访问数组上下文,集合和索引，逻辑和算术操作，命名变量名，和通过名字（name）从 Spring IoC 容器中检索对象。它也支持投影列表和选择，以及常见的列表汇总。
t/articles/injection.html.

动力节点 java笔记

动力节点 java笔记English Answer:## Java Notes for Spring Data JPA.### Introduction.Spring Data JPA is a powerful framework that provides a simplified and consistent access to relational data. It's a part of the Spring family of frameworks and builds on top of Hibernate, a popular ORM (Object-Relational Mapping) library.### Benefits of Spring Data JPA.Using Spring Data JPA offers several advantages:Abstraction and Simplification: It simplifies data access operations, eliminating the need for complex SQL queries and boilerplate code.Improved Performance: By leveraging Hibernate's caching and optimization techniques, Spring Data JPA enhances data retrieval efficiency.Consistency: Enforces consistent data access patterns and reduces the risk of data inconsistencies.Support for Transactions: Provides transparent transaction management, ensuring data integrity and atomicity.Declarative Configuration: Allows for configuration through annotations, simplifying database mapping and reducing code complexity.### Setting Up Spring Data JPA.To use Spring Data JPA, you'll need:Java Development Kit (JDK): Version 8 or higher.Maven or Gradle: Build tools for adding Spring Data JPA dependencies.JPA Provider: Hibernate or EclipseLink.Add the following dependencies to your project'spom.xml (Maven) or build.gradle (Gradle):xml.<!-Maven -->。

Spring

Spring是一个轻量级的DI（IoC）和AOP容器框架。

存在的目的是用于构建轻量级的J2EE应用。

1.轻量级：应用大小和应用开支，包括应用方式2.DI（IoC)：提供松耦合的一种实现技术3.AOP：切面编程将业务逻辑从应用服务中分离4.容器：包含并管理应用对象的生命周期和配置5.框架：使用组件配置组合成复杂的应用，并提供很多基础功能项目中引入spring立即可以带来下面的好处1.降低组件之间的耦合度,实现软件各层之间的解耦。

2.可以使用容器提供的众多服务，如：事务管理服务、消息服务等等。

当我们使用容器管理事务时，开发人员就不再需要手工控制事务.也不需处理复杂的事务传播。

3.容器提供单例模式支持，开发人员不再需要自己编写实现代码。

4.容器提供了AOP技术，利用它很容易实现如权限拦截、运行期监控等功能。

5.容器提供的众多辅作类，使用这些类能够加快应用的开发，如：JdbcT emplate、HibernateT emplate。

6.Spring对于主流的应用框架提供了集成支持，如：集成Hibernate、JPA、Struts等，这样更便于应用的开发。

第一个Spring应用(1):搭建环境,在spring最基础的应用中只需要dest\spring.jar和lib\jakarta-commons\commons-logging.jar新建spring的配置文件,文件名称可以任意,位置也可以任意,但考虑到通用性,一般将配置文件存放在类路径下,配置文件的模板可以在spring 参考手册中获取(查找中输入<bean>),模板大致如下：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd"></beans>(2):实例化spring容器,通过在类路径下寻找配置文件(配置文件可以有多个,以字符数组的形式传入)/* 当存在多个配置文件时,可以将spring配置文件名,字符串数组的形式传入 */ ApplicationContext ac = new ClassPathXmlApplicationContext("Spring-config.xml");(3):将实体bean的创建与维护交由spring管理在配置文件中的<beans>下使用<bean>标签<!—指定实体bean的名称,当名称含有特殊字符时,需要用name指定,一般情况下使用id,id 在配置文件中唯一,而name可以重复指定,获取时,获取到最后一个,在name中可以使用逗号将多个名称隔开,来达到指定bean的多个名称,当id和那么都没有指定时,则以类的全名作为name,如果存在多个name和id没有指定且实例类都是一样的bean,可以使用clazzpath/#来获取,#代表在xml中存在的序号--><!—calss指定需要被管理的实体bean,需要是完整的类名--><bean id="personService"class="com.mrkay.spring.services.impl.PersonServiceImpl"/> (4):调用实体bean使用实例化的spring容器的getBean(beanNa me)获取实体bean实例化bean的三种方式（1）：使用默认的构造函数进行实例化bean<bean id=”xxx” class=”xxx.xxx.Xxx”/>（2）：使用静态工厂方法创建bean<bean id=”xxx” class=”xxx.xxx.Xxx” factory-method=”xxxx”/>（3）：使用实例化工厂方法创建bean1,先实例化工厂<bean id=”factory” class=”xxx.xxx.Xxx”/>2,然后实例化bean <bean id=”xxx” class=”xxx.xxx.Xxx” factory-method=”xxxx”/>默认情况下会在容器启动时初始化bean，但我们可以指定Bean节点的lazy-init=“true”来延迟初始化bean，这时候，只有第一次获取bean会才初始化bean。

spring4中文技术手册==

在《静态代理和动态代理》中提到了面向方面编程，主要就是基于动态代理。

单独抽象出非业务的功能，服务于某些业务方法。

Spring提供了四种很实用的Advice，分别为：Before Advice, After Returning Advice, Around Advice, After throwing Advice。

都是方法级别的，就是在某个方法执行前后插入一些非业务的操作，如打日志或者判断权限等。

对于这四种advice的实现，spring都提供了三种方法，分别为基于接口、基于xml和基于annotation(注释)。

Before Advice会在目标对象的方法执行之前被调用；After Advice会在目标方法执行之后被调用；Around Advice则可以在目标方法执行前后同时加上相关服务；Throw Advice是在异常发生后执行某些操作。

1.基于接口的Advice这个就需要自定义的Aspect实现Spring接口。

BeforeAdvice需要实现org.springframework.aop.MethodBeforeAdvice接口：After Advice实现org.springframework.aop.AfterReturningAdvice接口：Around Advice需要实现org.aopalliance.intercept.MethodInterceptor接口：类前面的注释说明了该方法的使用，就是要在invoke()方法中调用MethodInvocation.proceed()，将执行传给下一个Interceptor，最终执行目标方法。

在proceed()方法前后加操作，到达Aroud advice的作用。

在Aspect定义好后，就需要在bean定义文件中进行配置，通过org.springframework.aop.framework.ProxyFactoryBean的配置，指出接口、目标类和Aspect。

spring框架案例学习文档笔记

(一) 搭建annotation开发环境....................................................................................................... 错误!未定义书签。

(二) aspectJ类库 ............................................................................................................................. 错误!未定义书签。

(三) AOP的annotation实例 .......................................................................................................... 错误!未定义书签。

(四) AspectJ的专业术语 ................................................................................................................. 错误!未定义书签。

(五) 织入点语法 .............................................................................................................................. 错误!未定义书签。

(六) Advice ....................................................................................................................................... 错误!未定义书签。

Spring初学者入门教程

2、自动装配（Autowring Properties） ....................................................................................... 14 3、bean 的定义的继承 ................................................................................................................. 14 4、bean 的依赖关系检查 ............................................................................................................. 15 5、scope ........................................................................................................................................ 15 六、BEAN 的生命周期 ............................................................................................................................................................................................................................................ 18 1、事件监听原理 .......................................................................................................................... 18

spr4

示例
8
Spring2.0
运行
9
Spring2.0
RegexpMethodPointcutAdvisor
Spring 提供的
org.springframework.aop.support.RegexpMethodPointcutAdvisor
使用Regular expression 来编写Pointcut表达式，其值为 “pattern”属性值
在mappedName属性上，指定了 “*Newbie”,所以执行helloNewbie() 方法时，应用logBeforeAdvice的逻辑 6
使用PointcutAdvisor提供Pointcut Spring2.0 实例
运行
7
Spring2.0
在上例中增加方法helloMaster执行时，执行logAfterAdvice?
提供静态的Pointcut实例，使用表达式指定Advice应用目标上的方法名称，或者用*来指定。注意：PointcutAdvisor为Advisor的子接口
4
Spring2.0
示例
已知下列接口：希望在方法helloNewbie执行前执行 LogBeforeAdvice
5
Spring2.0
代码分析
第四章
Spring AOP-II
Spring2.0
回顾
熟悉逻辑术语Cross-cutting concerns 理解AOP编程思想，着重在Aspect的设计上以及与应用程序的织入学会使用Spring AOP
2
Spring2.0
目标
继续熟悉各种Advice的设计与配置学会使用Pointcut 熟练掌握AOP编程

北京动力节点-Spring4讲义-第3章Spring与AOP

第3章Spring与AOP3.1 AOP的引入Step1：项目aop_leadin1先定义好接口与一个实现类，该实现类中除了要实现接口中的方法外，还要再写两个非业务方法。

非业务方法也称为交叉业务逻辑：doTransaction()：用于事务处理doLog()：用于日志处理然后，再使接口方法调用它们。

接口方法也称为主业务逻辑。

Step2：项目aop_leadin2此时提出一个问题：若有其它实现类同样也要调用这些事务、日志等处理方法怎么办？解决办法是，将这些日志、事务等方法包装到另外一个类中，让实现类继承这个类。

Step3：项目aop_leadin3以上的解决方案，也有一个弊端：若实现类还需要继承其它类，就不行了。

因为Java 不技术多继承。

当然，也可以有另一种解决方案：将这些交叉业务逻辑代码放到专门的工具类或处理类中，由主业务逻辑调用。

Step4：项目aop_leadin4以上的解决方案，还是存在弊端：交叉业务与主业务深度耦合在一起。

当交叉业务逻辑较多时，在主业务代码中会出现大量的交叉业务逻辑代码调用语句，大大影响了主业务逻辑的可读性，降低了代码的可维护性，同时也增加了开发难度。

所以，可以采用动态代理方式。

动态代理是OCP开发原则的一个重要体现：在不修改主业务逻辑的前提下，扩展和增强其功能。

3.2 AOP概述3.2.1 AOP简介AOP（Aspect Orient Programming），面向切面编程，是面向对象编程OOP的一种补充。

面向对象编程是从静态角度考虑程序的结构，而面向切面编程是从动态角度考虑程序运行过程。

AOP底层，就是采用动态代理模式实现的。

采用了两种代理：JDK的动态代理，与CGLIB 的动态代理。

面向切面编程，就是将交叉业务逻辑封装成切面，利用AOP容器的功能将切面织入到主业务逻辑中。

所谓交叉业务逻辑是指，通用的、与主业务逻辑无关的代码，如安全检查、事务、日志等。

若不使用AOP，则会出现代码纠缠，即交叉业务逻辑与主业务逻辑混合在一起。

Spring的基础学习

Spring的基础学习Spring1.spring 概述1）Spring 的创始人：Rod Johnson。

2）Spring 大大简化了Java企业级开发，提供了强大，稳定的功能，又没有带来额外的负担。

Spring 有两个主要目标：一是让现有技术更易于使用，二是促进良好的编程习惯（或称为最佳实践）。

3）Spring 是一个全面的解决方案。

但它坚持一个原则：不重造轮子。

已经有较好解决方案的领域，Spring决不做重复性的实现，比如对象持久化和OR映射，Spring只是对现有的JDBC，Hibernate，JPA 等技术提供支持。

4）Spring框架包含许多特性，并被很好地组织在下图所示的七个模块中。

下面将依次介绍每个模块。

Spring提供了一个稍微简单的Spring Web MVC框架，但应用不多。

2．分述在这里我们不做Spring的全面介绍。

我们只着重介绍Spring Core，Spring DAO这两个模块1）Spring CoreIOC就是 DAO接口的实现不再是业务逻辑层调用工厂类去获取，而是通过容器（比如spring）来自动的为我们的业务层设置DAO的实现类。

这样整个过程就反过来，以前是我们业务层主动去获取DAO，而现在是DAO主动被设置到业务逻辑层中来了，这也就是反转控制的由来。

通过IOC，我们就可以在不修改任何代码的情况下，无缝的实现数据库的换库迁移，当然前提还是必须得写一个实现特定数据库的DAO。

我们把DAO普遍到更多的情况下，那么IOC就为我们带来更大的方便性，比如一个接口的多个实现，我们只需要配置一下就ok了，而不需要再一个个的写工厂来来获取了。

这就是IOC为我们带来的模块的松耦合和应用的便利性。

其实IOC说白了其实就是由我们平常的new转成了使用反射来获取类的实例。

依赖注入（Dependency Injection ,DI）所谓依赖注入，就是明确地定义组件接口，独立开发各个组件，然后根据组件间的依赖关系组装运行的设计开发模式。