Spring2.5的新特性

合集下载

283-《JAVAEE技术》课程教学大纲

283-《JAVAEE技术》课程教学大纲

《JAVA EE技术》课程教学大纲课程编号: 0806602025课程名称: JAVA EE 技术英文名称: JAVA EE Technology 课程类型:专业限选课 / 任选课总学时: 48 讲课学时: 36 上机学时: 12 学分: 3适用对象:计算机科学与技术专业本科生先修课程:C/C++程序设计、JAVA基础、计算机网络、数据库原理及应用一、课程性质、目的和任务《JAVAEE技术》是计算机科学与技术专业本科生的一门专业基础限选课程。

通过本课程的学习可以使学生能够掌握 JAVA EE架构的基本理论、方法,能够掌握JAVA EE中的各种框架思想与技术,如 Struts、Spring、Hibernate(SSH)等,同时能够掌握运用 SSH进行软件系统开发的基本方法和运用并能够进行正确的测试。

通过本课程的学习,学生能够熟练运用SSH深入理解 MVC( Struts )的思想、Hibernate的思想、Spring的控制反转(loC)、依赖注入 (DI) 、面向切面编程的思想以及单元测试技术,并能够掌握和理解常见的软件设计模式,能够运用SSH开发出简单的软件系统。

二、教学基本要求本课程的基本要求如下:1.掌握 Struts 的思想、方法、配置和使用;2.掌握 Hibernate 的思想、方法、配置和使用;3.掌握 Spring 的思想、方法、配置和使用;4. 掌握 Struts 、 Spring 、 Hibernate(SSH) 的整合;5.掌握常用的软件测试方法和工具;6.能够运用 Struts 、 Spring 、 Hibernate(SSH) 开发简单的应用系统。

三、教学内容及要求1. Struts 、 Spring 、 Hibernate(SSH) 概述框架概述软件的分层设计子系统级的“高内聚、低耦合”Struts 、 Spring 、 Hibernate(SSH) 简介2.项目分析设计及软件设计模式项目开发流程(项目开发的生命周期及开发阶段)软件设计模式简介 ( 工厂方法模式、抽象工厂模式、代理模式、模板模式等几个常用的设计模式 )3. Struts 技术MVC莫式概述MVC与 Struts 映射Struts 的工作流程和配置文件Controller 组件分析及应用 Model 组件分析及应用 View 组件分析及应用Struts 的异常机制转换器数据验证( Validation ) 拦截器( Interceptor )4. Hibernate 技术Hibernate 概述Hibernate 单表的对象 / 关系数据库映射( PO、 DAO)Hibernate 多表的对象 / 关系数据库映射HQL 语言( Hibernate Query Language )Hibernate 过滤器( filters ) 对象状态管理继承映射组件(Component)映射性能优化批量处理5. Spring 技术Spring 2.0 的新特性Spring 控制反转 IoCSpring AOP 面向方面编程原理事务处理6. Struts 、 Spring 、Hibernate(SSH) 整合 Spring 与 Struts 整合 Spring 与 Hibernate 整合 Spring 、 Struts 、Hibernate 整合7.软件测试技术 JUnit 单元测试简介JMeter 系统测试8.基于SSH的实例开发及分析例如:在线考试系统、电子拍卖系统、网上商店、电子相册等系统的开发与分析。

Spring2.5与2.0区别的适用范围.

Spring2.5与2.0区别的适用范围.

123132131312321d3sa1d31d3as1f3as21 spring2.0和spring2.5 及以上版本的jar 包区别 spring jar 包详解 spring jar 包详解 spring.jar是包含有完整发布的单个jar 包,spring.jar中包含除了 spring-mock.jar里所包含的内容外其它所有jar包的内容,因为只有在开发环境下才会用到spring-mock.jar来进行辅助测试,正式应用系统中是用不得这些类的。

除了spring.jar文件,Spring还包括有其它13个独立的jar包,各自包含着对应的 Spring组件,用户可以根据自己的需要来选择组合自己的jar包,而不必引入整个spring.jar的所有类文件。

(1 spring-core.jar 这个jar文件包含Spring框架基本的核心工具类,Spring其它组件要都要使用到这个包里的类,是其它组件的基本核心,当然你也可以在自己的应用系统中使用这些工具类。

(2 spring-beans.jar 这个jar文件是所有应用都要用到的,它包含访问配置文件、创建和管理bean以及进行Inversion of Control / Dependency Injection(IoC/DI)操作相关的所有类。

如果应用只需基本的IoC/DI支持,引入spring-core.jar及spring- beans.jar文件就可以了。

(3 spring-aop.jar 这个jar文件包含在应用中使用Spring的AOP特性时所需的类。

使用基于AOP的Spring特性,如声明型事务管理(Declarative Transaction Management),也要在应用里包含这个jar包。

(4 spring-context.jar 这个jar文件为 Spring核心提供了大量扩展。

可以找到使用Spring ApplicationContext特性时所需的全部类,JDNI所需的全部类,UI方面的用来与模板(Templating)引擎如 Velocity、FreeMarker、JasperReports集成的类,以及校验Validation方面的相关类。

Spring初学文档

Spring初学文档

Spring2.5注释驱动8.4.1 Spring2.5注释驱动注释语法越来越多的被业界所使用,并且注释配置相对于 XML 配置具有很多的优势:它可以充分利用 Java 的反射机制获取类结构信息,这些信息可以有效减少配置的工作。

注释和 Java 代码位于一个文件中,而 XML 配置采用独立的配置文件,大多数配置信息在程序开发完成后都不会调整,如果配置信息和Java 代码放在一起,有助于增强程序的内聚性。

而采用独立的 XML 配置文件,程序员在编写一个功能时,往往需要在程序文件和配置文件中不停切换,这种思维上的不连贯会降低开发效率。

因此在很多情况下,注释配置比 XML 配置更受欢迎,注释配置有进一步流行的趋势。

Spring 2.5 的一大增强就是引入了很多注释类,现在您已经可以使用注释配置完成大部分 XML 配置的功能。

在使用注释配置之前,先来回顾一下传统上是如何配置 Bean 并完成 Bean 之间依赖关系的建立。

代码清单1 Foo.java Foo对象有一个String类型的name属性.package ;public class Foo {private String name;public String toStirng(){return"Foo Name is :" + ;}Set和get方法}代码清单2 Bar.java Bar对象有一个String类型的add属性.package ;public class Bar {private String add;public String toStirng(){return"Bar Add is :" + this.add;}Set和get方法}代码清单3 Main.java Main对象有两个属性分别是Foo和Bar package ;public class Main {private Foo foo;private Bar bar;public String toString(){return"Main : [" + +" "+ + "]";}Set和get方法}代码清单4 配置文件spring-config-beans.xml<bean id="main" class=""><property name="foo" ref="foo"></property><property name="bar" ref="bar"></property></bean><bean id="foo" class=""><property name="name" value="Foo"></property></bean><bean id="bar" class=""><property name="add" value="Bar"></property></bean>代码清单 5 Test.java Test类用于初始化Spring容器并获得main对象package ;import ;importClassPathXmlApplicationContext;public class Test {public static void main(String[] args) {String[] locations = {"spring-config-beans.xml"}; ApplicationContext ctx = new ClassPathXmlApplicationContext(locations);Main main = (Main) ctx.getBean("main");;}}运行Test类控制台输出以下信息:Main : [Foo Name is :Foo Bar Add is :Bar]这说明Spring已经完成了Bean的创建和装配工作。

spring2.5

spring2.5

Spring2.51.搭建环境Jar包:dist\spring.jarlib\jakarta-commons\commons-logging.jar如果使用了切面编程(AOP),还需要下列jar文件lib/aspectj/aspectjweaver.jar和aspectjrt.jarlib/cglib/cglib-nodep-2.1_3.jar如果使用了JSR-250中的注解,如@Resource/@PostConstruct/@PreDestroy,还需要下列jar文件lib\j2ee\common-annotations.jar配置文件:配置文件的取名可以任意,文件可以存放在任何目录下,但考虑到通用L2.项目开发实例化Bean (从spring容器中得到bean)3.管理bean的作用域设置延迟初始化:lazy-init=“true”------------ 对某个指定的bean设置在default-lazy-init="true" ---------------全局◆Bean的生命周期* 会在创建实例的同时执行init()方法* 在spring正常关闭时执行destory()方法要继承AbstractApplicationContext中close()方法4.依赖注入◆IOC控制反转所谓控制反转就是应用本身不负责依赖对象的创建及维护,依赖对象的创建及维护是由外部容器负责的。

这样控制权就由应用转移到了外部容器,控制权的转移就是所谓反转。

◆面向接口编程✧Service,Dao,,Web层为了降低耦合性,让各层之间的依赖,通过接口来完成◆◆使用构造器注入使用属性setter方法注入使用Field注入(用于注解方式)注入依赖对象可以采用手工装配或自动装配,在实际应用中建议使用手工装配,因为自5.让Spring自动扫描和管理Bean1)<context:component-scan base-package="cn.itcast"/>2)@Service用于标注业务层组件、@Controller用于标注控制层组件(如struts 中的action)、@Repository用于标注数据访问组件,即DAO组件。

Spring2.5 注解介绍(3.0通用)

Spring2.5 注解介绍(3.0通用)

Spring2.5 注解介绍(3.0通用)注解说明•注册注解处理器•方式一:bean<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>•方式二: 命名空间<context:annotation-config /><context:annotationconfig /> 将隐式地向Spring 容器注册AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor 、 PersistenceAnnotationBeanPostProcessor 以及RequiredAnnotationBeanPostProcessor 这4 个BeanPostProcessor 。

•方式三: 命名空间<context:component-scan />如果要使注解工作,则必须配置component-scan ,实际上不需要再配置annotation-config。

base-package 属性指定了需要扫描的类包,类包及其递归子包中所有的类都会被处理。

还允许定义过滤器将基包下的某些类纳入或排除。

• Spring 支持以下4 种类型的过滤方式:•注解 org.example.SomeAnnotation 将所有使用SomeAnnotation 注解的类过滤出来•类名指定 org.example.SomeClass 过滤指定的类•正则表达式 com.kedacom.spring.annotation.web..* 通过正则表达式过滤一些类• AspectJ 表达式 org.example..*Service+ 通过AspectJ 表达式过滤一些类•正则表达式的过滤方式举例:<context:component-scanbase-package="com.casheen.spring.annotation"><context:exclude-filtertype="regex"expression="com.casheen.spring.annotation.web..*"/></context:component-scan>•注解的过滤方式举例:<context:component-scan base-package="qin" ><context:include-filter type="annotation"expression="org.springframework.stereotype.Controller"/><context:include-filter type="annotation"expression="org.springframework.stereotype.Service"/><context:include-filter type="annotation"expression="org.springframework.stereotype.Repository"/></context:component-scan>启用Spring MVC 注解•启动Spring MVC 的注解功能,完成请求和注解POJO 的映射• <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/>注解介绍• @Controller• @Service• @Autowired• @RequestMapping• @RequestParam• @ModelAttribute• @Cacheable• @CacheFlush• @Resource• @PostConstruct• @PreDestroy• @Repository• @Component (不推荐使用)• @Scope• @SessionAttributes• @InitBinder@Controller•例如@Controllerpublic class SoftCreateController extends SimpleBaseController {}•或者@Controller("softCreateController")•说明@Controller 负责注册一个bean 到spring 上下文中,bean 的ID 默认为类名称开头字母小写@Service•例如@Servicepublic class SoftCreateServiceImpl implements ISoftCreateService {}•或者@Service("softCreateServiceImpl")•说明@Service 负责注册一个bean 到spring 上下文中,bean 的ID 默认为类名称开头字母小写@Autowired•例如@Autowiredprivate ISoftPMService softPMService;•或者@Autowired(required=false)private ISoftPMService softPMService = new SoftPMServiceImpl();•说明@Autowired 根据bean 类型从spring 上线文中进行查找,注册类型必须唯一,否则报异常。

Spring5核心原理与30个类手写实战pdf下载

Spring5核心原理与30个类手写实战pdf下载

Spring5核心原理与30个类手写实战pdf下载基于编程开发实践,不仅深度解析Spring 5的原理与新特性,更从环境准备、顶层结构设计、数据访问等方面一步步地推导出Spring的设计原理。

在每个知识点上,均以大量的经典代码案例辅助讲解,使理论紧密联系实际。

最后手写30个类,以体会Spring的创作过程,让每一位读者学以致用。

Spring5核心原理与30个类手写实战资料目录第1篇 Spring内功心法第1章软件架构设计原则 21.1 开闭原则 21.2 依赖倒置原则 41.3 单一职责原则 71.4 接口隔离原则 101.5 迪米特原则 121.6 里氏替换原则 141.7 合成复用原则 191.8 设计原则总结 20第2章 Spring中常用的设计模式 212.1 为什么要从设计模式开始 212.1.1 写出优雅的代码 222.1.2 更好地重构项目 242.1.3 经典框架都在用设计模式解决问题 36 2.2 工厂模式详解 362.2.1 工厂模式的由来 362.2.2 简单工厂模式 372.2.3 工厂方法模式 412.2.4 抽象工厂模式 432.2.5 利用工厂模式重构的实践案例 472.3 单例模式详解 532.3.1 单例模式的应用场景 532.3.2 饿汉式单例模式 532.3.3 懒汉式单例模式 542.3.4 反射破坏单例 602.3.5 序列化破坏单例 612.3.6 注册式单例模式 682.3.7 线程单例实现ThreadLocal 742.3.8 单例模式小结 752.4 原型模式详解 752.4.1 原型模式的应用场景 752.4.2 浅克隆 772.4.3 深克隆 792.4.4 克隆破坏单例模式 812.4.5 clone()方法的源码 822.5 代理模式详解 822.5.1 代理模式的应用场景 822.5.2 静态代理 832.5.3 动态代理 882.5.4 代理模式与Spring 1072.5.5 静态代理和动态代理的本质区别 1082.5.6 代理模式的优缺点 1092.6 委派模式详解 1092.6.1 委派模式的定义及应用场景 1092.6.2 委派模式在源码中的体现 1112.7 策略模式详解 .1142.7.1 策略模式的应用场景 1142.7.2 用策略模式实现选择支付方式的业务场景 .114 2.7.3 策略模式在JDK源码中的体现 1222.7.4 策略模式的优缺点 1252.7.5 委派模式与策略模式综合应用 1252.8 模板模式详解 1292.8.1 模板模式的应用场景 1292.8.2 利用模板模式重构JDBC操作业务场景 132 2.8.3 模板模式在源码中的体现 1362.8.4 模板模式的优缺点 1382.9 适配器模式详解1392.9.1 适配器模式的应用场景 1392.9.2 重构第三方登录自由适配的业务场景141 2.9.3 适配器模式在源码中的体现 1492.9.4 适配器模式的优缺点 1532.10 装饰者模式详解 1532.10.1 装饰者模式的应用场景 1532.10.2 装饰者模式和适配器模式对比 1632.10.3 装饰者模式在源码中的应用 1632.10.4 装饰者模式的优缺点 1652.11 观察者模式详解 1652.11.1 观察者模式的应用场景 1652.11.2 观察者模式在源码中的应用 1752.11.3 基于Guava API轻松落地观察者模式 176 2.11.4 观察者模式的优缺点 1772.12 各设计模式的总结与对比 177 2.12.1 GoF 23种设计模式简介 177 2.12.2 设计模式之间的关联关系 178 2.12.3 Spring中常用的设计模式 182 2.13 Spring中的编程思想总结 183 第2篇 Spring环境预热第3章 Spring的前世今生 1863.1 一切从Bean开始 1873.2 Spring的设计初衷 1883.3 BOP编程伊始 1883.4 理解BeanFactory 1893.5 AOP编程理念 189第4章 Spring 5系统架构 1914.1 核心容器 1924.2 AOP和设备支持1924.3 数据访问与集成1934.4 Web组件 1944.5 通信报文 1944.6 集成测试 1944.7 集成兼容 1944.8 各模块之间的依赖关系 194第5章 Spring版本命名规则 1965.1 常见软件的版本命名 1965.2 语义化版本命名通行规则 1975.3 商业软件中常见的修饰词 1975.4 软件版本号使用限定 1985.5 Spring版本命名规则 199第6章 Spring源码下载及构建技巧 2006.1 Spring 5源码下载 2006.2 基于Gradle的源码构建技巧 2016.3 Gradle构建过程中的坑 207第3篇 Spring核心原理第7章用300行代码手写提炼Spring核心原理 210 7.1 自定义配置 2107.1.1 配置application.properties文件 2107.1.2 配置web.xml文件 2107.1.3 自定义注解 2117.1.4 配置注解 2127.2 容器初始化 2137.2.1 实现1.0版本 2137.2.2 实现2.0版本 2167.2.3 实现3.0版本 2237.3 运行效果演示 227第8章一步一步手绘Spring IoC运行时序图 228 8.1 Spring核心之IoC容器初体验 2288.1.1 再谈IoC与DI 2288.1.2 Spring核心容器类图 2298.1.3 Web IoC容器初体验 2328.2 基于XML的IoC容器的初始化 2378.2.1 寻找入口 2388.2.2 获得配置路径 2388.2.3 开始启动 2408.2.4 创建容器 2428.2.5 载入配置路径 2438.2.6 分配路径处理策略 2448.2.7 解析配置文件路径 2478.2.8 开始读取配置内容 2498.2.9 准备文档对象 2508.2.10 分配解析策略 2518.2.11 将配置载入内存 2528.2.12 载入<bean>元素 2578.2.13 载入<property>元素 2618.2.14 载入<property>子元素 2648.2.15 载入<list>子元素 2668.2.16 分配注册策略 2678.2.17 向容器注册 2678.3 基于注解的IoC初始化 2708.3.1 注解的前世今生 2708.3.2 定位Bean扫描路径 2718.3.3 读取注解的元数据 2738.3.4 扫描指定包并解析为BeanDefinition 277 8.3.5 注册注解BeanDefinition 2838.4 IoC容器初始化小结 285第9章一步一步手绘Spring DI运行时序图 287 9.1 Spring自动装配之依赖注入 2879.1.1 依赖注入发生的时间 2879.1.2 寻找获取Bean的入口 2889.1.3 开始实例化 2939.1.4 选择Bean实例化策略 2979.1.5 执行Bean实例化 2999.1.6 准备依赖注入 3019.1.7 解析属性依赖注入规则 3069.1.8 注入赋值 3109.2 Spring IoC容器中那些鲜为人知的细节 314 9.2.1 关于延时加载 3149.2.2 关于FactoryBean和BeanFactory 3179.2.3 再述autowiring 322第10章一步一步手绘Spring AOP运行时序图 326 10.1 Spring AOP初体验 32610.1.1 再述Spring AOP应用场景 32610.1.2 AOP中必须明白的几个概念 32710.1.3 使用Spring AOP的两种方式 32910.1.4 切入点表达式的配置规则 33310.2 Spring AOP源码分析 33410.2.1 寻找入口 33410.2.2 选择代理策略 33810.2.3 调用代理方法 34110.2.4 触发通知 347第11章一步一步手绘Spring MVC运行时序图 352 11.1 初探Spring MVC请求处理流程 35211.2 Spring MVC九大组件 35311.2.1 HandlerMapping 35311.2.2 HandlerAdapter 35311.2.3 HandlerExceptionResolver 354 11.2.4 ViewResolver 35411.2.5 RequestToViewNameTranslator 354 11.2.6 LocaleResolver 35411.2.7 ThemeResolver 35511.2.8 MultipartResolver 35511.2.9 FlashMapManager 35511.3 Spring MVC源码分析 35511.3.1 初始化阶段 35611.3.2 运行调用阶段 35911.4 Spring MVC优化建议 367第4篇 Spring手写实战第12章环境准备 37012.1 IDEA集成Lombok插件 37012.1.1 安装插件 37012.1.2 配置注解处理器 37312.1.3 使用插件 37412.2 从Servlet到ApplicationContext 375 12.3 准备基础配置37612.3.1 application.properties配置.377 12.3.2 pom.xml配置 37712.3.3 web.xml配置 37812.3.4 GPDispatcherServlet 378第13章 IoC顶层结构设计 38013.1 Annotation(自定义配置)模块 380 13.1.1 @GPService 38013.1.2 @GPAutowired 38113.1.3 @GPController 38113.1.4 @GPRequestMapping 38213.1.5 @GPRequestParam 38213.2 core(顶层接口)模块 38213.2.1 GPFactoryBean 38213.2.2 GPBeanFactory 38313.3 beans(配置封装)模块 38313.3.1 GPBeanDefinition 38313.3.2 GPBeanWrapper 38413.4 context(IoC容器)模块 38513.4.1 GPAbstractApplicationContext 385 13.4.2 GPDefaultListableBeanFactory 385 13.4.3 GPApplicationContext38513.4.4 GPBeanDefinitionReader 38813.4.5 GPApplicationContextAware 391第14章完成DI模块的功能 39214.1 从getBean()方法开始 39314.2 GPBeanPostProcessor 395第15章完成MVC模块的功能 39615.1 MVC顶层设计 39615.1.1 GPDispatcherServlet 39615.1.2 GPHandlerMapping 40215.1.3 GPHandlerAdapter 40315.1.4 GPModelAndView 40615.1.5 GPViewResolver 40615.1.6 GPView 40715.2 业务代码实现40915.2.1 IQueryService 40915.2.2 QueryService 41015.2.3 IModifyService 41015.2.4 ModifyService 41115.2.5 MyAction 41215.2.6 PageAction 41315.3 定制模板页面41415.3.1 first.html 41415.3.2 404.html 41415.3.3 500.html 41515.4 运行效果演示415第16章完成AOP代码织入 417 16.1 基础配置 .41716.2 完成AOP顶层设计 41816.2.1 GPJoinPoint 41816.2.2 GPMethodInterceptor .419 16.2.3 GPAopConfig 41916.2.4 GPAdvisedSupport 420 16.2.5 GPAopProxy 42216.2.6 GPCglibAopProxy 42316.2.7 GPJdkDynamicAopProxy 423 16.2.8 GPMethodInvocation425 16.3 设计AOP基础实现 42716.3.1 GPAdvice 42716.3.2 GPAbstractAspectJAdvice 427 16.3.3 GPMethodBeforeAdvice 428 16.3.4 GPAfterReturningAdvice 429 16.3.5 GPAfterThrowingAdvice 430 16.3.6 接入getBean()方法 43016.4 织入业务代码43216.4.1 LogAspect 43216.4.2 IModifyService 43316.4.3 ModifyService 43416.5 运行效果演示435第5篇 Spring数据访问第17章数据库事务原理详解 438 17.1 从Spring事务配置说起 438 17.2 事务的基本概念 43917.3 事务的基本原理 43917.4 Spring事务的传播属性 440 17.5 数据库事务隔离级别 44117.6 Spring中的事务隔离级别 441 17.7 事务的嵌套 44217.8 Spring事务API架构图 44417.9 浅谈分布式事务 444第18章 Spring JDBC源码初探 44618.1 异常处理 44718.2 config模块 44818.3 core模块45018.4 DataSource 45618.5 object模块 45718.6 JdbcTemplate 45818.7 NamedParameterJdbcTemplate 458第19章基于Spring JDBC手写ORM框架 459 19.1 实现思路概述45919.1.1 从ResultSet说起 45919.1.2 为什么需要ORM框架 46419.2 搭建基础架构46719.2.1 Page 46719.2.2 ResultMsg 47019.2.3 BaseDao 47119.2.4 QueryRule 47319.2.5 Order.47919.3 基于Spring JDBC实现关键功能 480 19.3.1 ClassMappings 48019.3.2 EntityOperation 48319.3.3 QueryRuleSqlBuilder 48819.3.4 BaseDaoSupport 49819.4 动态数据源切换的底层原理 50719.4.1 DynamicDataSource 50819.4.2 DynamicDataSourceEntry 50919.5 运行效果演示51019.5.1 创建Member实体类 51019.5.2 创建Order实体类 51119.5.3 创建MemberDao 51219.5.4 创建OrderDao 51219.5.5 修改db.properties文件 51419.5.6 修改application-db.xml文件 515 19.5.7 编写测试用例 516第6篇 Spring经验分享第20章 Spring 5新特性总结 52020.1 升级到Java SE 8和Java EE 7 520 20.2 反应式编程模型 52120.3 使用注解进行编程 52120.4 函数式编程 52220.5 使用 REST 端点执行反应式编程 52320.6 支持HTTP/2 52320.7 Kotlin和Spring WebFlux 52320.8 使用Lambda表达式注册Bean 52420.9 Spring Web MVC 支持最新的 API 52420.10 使用JUnit 5执行条件和并发测试 52520.11 包清理和弃用 52620.12 Spring核心和容器的一般更新 52620.13 我如何看Spring 5 527第21章关于Spring的经典高频面试题 52821.1 什么是Spring框架,Spring框架有哪些主要模块52821.2 使用Spring框架能带来哪些好处 52821.3 什么是控制反转(IoC),什么是依赖注入 52921.4 在Java中依赖注入有哪些方式 52921.5 BeanFactory和ApplicationContext有什么区别 530 21.6 Spring提供几种配置方式来设置元数据 53021.7 如何使用XML配置方式配置Spring .53121.8 Spring提供哪些配置形式 53221.9 怎样用注解的方式配置Spring 53321.10 请解释Spring Bean的生命周期 53421.11 Spring Bean作用域的区别是什么 53521.12 什么是Spring Inner Bean 53521.13 Spring中的单例Bean是线程安全的吗 53621.14 请举例说明如何在Spring中注入一个Java集合 53621.15 如何向Spring Bean中注入java.util.Properties 53721.16 请解释Spring Bean的自动装配 53821.17 自动装配有哪些局限性 53821.18 请解释各种自动装配模式的区别 53921.19 请举例解释@Required注解 53921.20 请举例说明@Qualifier注解 54021.21 构造方法注入和设值注入有什么区别 54021.22 Spring中有哪些不同类型的事件 54121.23 和ClassPathResource有什么区别 54221.24 Spring中用到了哪些设计模式 54221.25 在Spring中如何更有效地使用JDBC 54321.26 请解释Spring中的IoC容器 54321.27 在Spring中可以注入null或空字符串吗 543Spring5核心原理与30个类手写实战介绍1996年,Java还只是一个新兴的、初出茅庐的编程语言。

Spring Framework 部分5

Spring Framework 部分5

Spring 2.0 的新特性如果你已经用了一段时间Spring Framework,那你将发现Spring正在经历着一场大的修订。

修订版引入一些新特性,总结并改进了许多现有功能。

实际上,Spring得到了大量有价值的更新,以至于Spring开发团队决定在Spring的下一个版本里修改版本号;所以2005年12月,在佛罗里达召开的Spring经验交流会上,Spring 2.0 问世了。

本章是对Spring 2.0新特性与改进特性的向导。

我们希望提供一个高层的概述使那些有经验的Spring架构师与开发人员能很快熟悉Spring 2.0的新功能。

如果想了解关于特性更多更深层的信息,请参考在本章里超链接的相应部分。

下面介绍的一些新的或者改进的功能已经(或将要)被加入Spring 1.2.x中。

如果想知道某功能是否被加入1.2.x版本中,请参考1.2.x发布包的changelog。

JDK支持Spring Framework继续保持与从Java 1.3开始的(包括1.3)所有Java版本的兼容性。

这意味着它支持1.3、1.4和1.5,尽管Spring Framework的一些高级功能无法在1.3中使用。

2.2. 控制反转(IoC)容器Spring 2.0 相当大的改进之一就是Spring的IoC容器。

2.2.1. 更简单的XML配置多亏了新的基于XML Schema的XML配置语法的产生,Spring的XML配置变的更加简单了。

如果你想充分利用Spring提供的新标签(Spring团队当然建议你这么做,因为他们使配置变的不再繁琐,更加易于阅读),请阅读标题为附录A, XML Schema-based configuration的部分。

相关提示,请引用新的Spring 2.0 DTD以使用基于XML Schema的配置。

下面给出了DOCTYPE声明,如果有兴趣的读者可以详细阅读Spring 2.0发布包的'dist/resources'目录中的'spring-beans-2.0.dtd' DTD。

Spring2.5声明式事务管理详解

Spring2.5声明式事务管理详解

大多数Spring用户选择声明式事务管理。

这是对应用代码影响最小的选择,因此也最符合非侵入式轻量级容器的理念。

Spring的声明式事务管理是通过Spring AOP实现的,因为事务方面的代码与Spring绑定并以一种样板式风格使用,不过尽管如此,你一般并不需要理解AOP概念就可以有效地使用Spirng的声明式事务管理。

从考虑EJB CMT和Spring声明式事务管理的相似以及不同之处出发是很有益的。

它们的基本方法是相似的:都可以指定事务管理到单独的方法;如果需要可以在事务上下文调用setRollbackOnly()方法。

不同之处在于:∙不像EJB CMT绑定在JTA上,Spring声明式事务管理可以在任何环境下使用。

只需更改配置文件,它就可以和JDBC、JDO、Hibernate或其他的事务机制一起工作。

∙Spring的声明式事务管理可以被应用到任何类(以及那个类的实例)上,不仅仅是像EJB那样的特殊类。

∙Spring提供了声明式的回滚规则:EJB没有对应的特性,我们将在下面讨论。

回滚可以声明式的控制,不仅仅是编程式的。

∙Spring允许你通过AOP定制事务行为。

例如,如果需要,你可以在事务回滚中插入定制的行为。

你也可以增加任意的通知,就象事务通知一样。

使用EJB CMT,除了使用setRollbackOnly(),你没有办法能够影响容器的事务管理。

∙Spring不提供高端应用服务器提供的跨越远程调用的事务上下文传播。

如果你需要这些特性,我们推荐你使用EJB。

然而,不要轻易使用这些特性。

因为通常我们并不希望事务跨越远程调用。

TransactionProxyFactoryBean在哪儿?Spring2.0及以后的版本中声明式事务的配置与之前的版本有相当大的不同。

主要差异在于不再需要配置TransactionProxyFactoryBean了。

Spring2.0之前的旧版本风格的配置仍然是有效的;你可以简单地认为新的<tx:tags/>替你定义了T ransactionProxyFactoryBean。

xxp-spring2.5

xxp-spring2.5

Spring2.51.控制反转就是应用本身不负责依赖对象的创建和维护, 而交给外部容器,2.DI是运行期由外部容器动态的将依赖对象注入到组件中3.需要包含的jara)必须的i.dist/spring.jarii.lib/jakarta-commons/commons-logging.jarb)切面编程aop, 还需要以下jari.lib/aspectj/aspectjweaver.jar 和aspectjrt.jarii.lib/cglib/cglib-nodep-2.1.3.jarc)如果使用了注解i.lib/j2ee/common-annotations.jar4.实例化Spring有两种方式a)类路径i.b)文件路径i.ii.在不同操作系统下不通用c)可以通过数组指定多个配置文件5.可以新建JUnit Test case来做实验6.可以先写类, 再通过eclipse来抽取接口7.bean的属性a)name属性是id的加强, 可以包含特殊字符8.bean的获得ApplicationContext ctx = new ClassPathXmlApplicationContext(newString[]{"bean.xml"});PersonService personService = (PersonService)ctx.getBean("PersonService");a)personService.save();9.Spring实例化bean的方式a)使用类的构造方法实例化b)使用静态工厂实例化i.这时候在配置的时候class指定的是工厂类, 还要指定工厂方法c)使用实例工厂方法实例化i.先实例工厂, 再用该工厂来实例化bean10.bean的作用域a)默认为单例可以通过配置文件中该bean的里面lazy-init=”true”来延迟实例化, 这时只有第一次获得时, 才会实例化b)prototype是每一次都是获得新实例c)还有request , session , global session 可以在web应用中使用11.bean的生命周期a)默认的时候是在容器实例化的时候对bean进行实例化b)scope=prototype的时候, 是在调用的时候才会进行实例化c)初始化方法, 如DBAgent中的获得连接的方法i.可以在xml里面的bean里面配置init-methodii.这样bean在被外部容器实例化之后, 就会调用这个方法d)也可以通过destory-method来指定bean被销毁的时候, 应该去调用哪个方法12.依赖注入a)通过bean的property属性, 把xml里面另一个bean注入进去b)通过ref描述另一个beanc)集合类型对象的注入i.Set类型ii.iii.List类型iv.v.Properties类型vi.vii.Map类型viii.d)通过构造函数注入两个参数举例e)13.编写Spring配置文件, 如果无法连接到网络a)window prefemence MyEclipseEnterpriseWorkBench xml xmlCatalogb)右边 user special entries 然后addc)14.通过注解把类进行依赖注入a)如果要用注解, spring的xml的beans里面要加上<context:annotation-config/>b)@Autowired是按类型装配i.c)@Resource是按名称装配, 当找不到与名称匹配的bean时就会按类型装配, 而且是属于j2ee的, 没有与框架进行耦合i.@Resource可以加上属性上, 也可以加在的set方法上面15.使用ClassPath自动扫描技术把类纳入spring容器管理a)在spring的xml里面的beans里面加上<context:component-scanbase-package=""/> 已经加入14中的命名空间b)@Service是标注业务层对象i.后面加(“名子”)ii.加@Scope(作用范围)iii.可以在方法上加@PostConstruct表示初始化方法iv.加上@PreDestroy是表示销毁方法c)@Controller是标注控制层的, (如Struts中的action)d)@Repository是标注数据访问组件, 即Dao组件e)@Component是泛指组件f)使用的时候, getBean(里面是类的名字, 第一个字母小写)16.aop代理a)要想使用aop, 目标类必须面向接口(非spring)b)切面是横切性关注点的抽象c)连接点是被拦截器拦截到的点d)切入点是要对哪些连接点进行拦截的定义e)拦截后所做的事情是通知f)织入是将切面应用到目标对象并将代理对象创建的过程g)引入是指不修改代码的前提下, 可以在运行期动态的添加一些方法或fieldh)如果类实现了接口, 就会用JDKProxyFactory来实现aop, 如果没有实现接口, 就会用CGlibProxyFactory来实现接口17.用注解使用Spring的aopa)@Aspect声明切面b)@Pointcut声明切入点i.即执行业务方法时要进行拦截ii.@Pointcut (“execution(* com.xxp..*.*(..))”) 第一个*是返回值类型, 后面是包名, 两个点表示对子包的类也要进行拦截, 第二个*是表示要对哪个类进行拦截, 第三个*是代表方法; 后面括号里面的点, 是代表参数iii.采用定义方法来定义切入点的名称iv.可以声明多个切入点c)@Before定义前通知i.可以定义参数到通知@Before(“anyMethod()&&args(userName)”)d)@AfterReturning定义后置通知i.要声明返回就 ,returning=”result”)ii.并且把通知方法里面的参数改为String resulte)@AfterThrowingi.要得到目标方法抛出的意外 ,throwing=”e”)ii.并且把通知方法里面的参数改为String result18.用xml实现aopa)<aop:config>b)<aop:aspect id="asp" ref="aspetbean">c)<aop:pointcut id="mycut" expression="execution(*cn.itcast.service..*.*(..))"/>d)<aop:before pointcut-ref="mycut" method="doAccessCheck"/>e)<aop:after-returning pointcut-ref="mycut"method="doAfterReturning"/>f)<aop:after-throwing pointcut-ref="mycut"method="doAfterThrowing"/>g)<aop:after pointcut-ref="mycut" method="doAfter"/>h)<aop:around pointcut-ref="mycut"method="doBasicProfiling"/>i)</aop:aspect>j) </aop:config>19.Spring加JDBCa)配置数据源i.<bean id = “datasource”></bean>ii.配置mySql的url的时候, & 应该用 &amp;b)配置事务i.如果要用注解来进行事务的声明,要在配置文件中加上<tx:annotation-driventransaction-manager="txManager"/>ii.txManager是一个事务管理器的bean:如1.<bean id="txManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">2. <property name="dataSource" ref="dataSource"/>3. </bean>c)使用模板类i.在service类里面定义一个私有变量JdbcTemplate, 然后用DataSource的set方法来初始化它ii.私有变量DataSource就没有必要了20.如果抛出的是运行期例外(即RuntimeException)的话, 事务会回滚a)如果是Exception, 也就是需要try catch的意外, 是不会回滚的b)但是对于Exception, 可以通过@Transaction(RollbackFor=””) 来强制回滚21.使用注解进行事务管理和事务的传播属性@Transactional(propagation =Propagation.NOT_SUPPORED)a)在类和方法上面都要加@Transactionb)REQUIRED业务方法需要在一个事务中运行, 如果方法在运行时已经在一个事务中了, 就加入该事务, 否则为自己创建一个新的事务c)NOT_SUPPORED 声明该方法不需要一个事务, 如果该方法在事务中被调用, 事务会被佳起, 当该方法执行完后, 事务便会恢复执行d)REQUIRESNEW 该方法需要一个新的事务, 如果该方法是在事务中被调用, 那么原来的事务会被挂起, 等一个为这个方法所新建的事务创建并执行完成以后, 再继续从前的事务e)MANDATORY该属性指定业务方法只能在一个已经存在的事务中进行, 业务方法不能自己发起事务, 如果在没有事务的环境中被调用, 容器就会抛出意外f)SUPPORTS 如果方法在有事务的环境中被调用, 就会成为该事务的一部分, 如果在没有事务的环境中被调用, 就会在没有事务的环境中执行g)Never 指定方法绝对不能在事务的范围内执行,22.数据库系统的四种隔离级别a)读未提交数据会出现脏读(读到另一事务未提交的数据)b)读已提交数据会出现不可重复读(后继读取可以读到另一事务已经提交的数据)和幻读c)可重复读会出现幻读(一个事务读到另一事务提交的insert数据)d)串行化23.使用xml配置事务a)<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">b) <property name="dataSource" ref="dataSource"/>c) </bean>d)e)<aop:config>f)<aop:pointcut id="transactionPointcut" expression="execution(*cn.itcast.service..*.*(..))"/>g)<aop:advisor advice-ref="txAdvice" pointcut-ref="h)transactionPointcut"/>i)</aop:config>j)<tx:advice id="txAdvice" transaction-manager="txManager">k) <tx:attributes>l) <tx:method name="get*" read-only="true" propagation="m)NOT_SUPPORTED"/>n) <tx:method name="*"/>o) </tx:attributes>p)</tx:advice>24.Spring2.5 + Hibernate3.3 + Struts1.3整合开发a)spring中的antlr 与 struts中的antlr会冲突b)Spring容器的实例化i.手工编码ii.交给web容器, 这时Spring的配置文件要放到web根目录下面, 也可以通过配置参数classpath来指定从类路径下寻找1.<context-param>2. <param-name>contextConfigLocation</param-name>3. <param-value>classpath:beans.xml</param-value>4.</context-param>5.<!-- 对Spring容器进行实例化 -->6.<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>7.</listener>iii.如果是交给web容器的, 以后就可以从servletContext中取出来iv.c)想更好的集成, 就应该把Action交给Spring管理, 不然每次都要在action中获得Spring上下文i.在struts中把RequestProcess换掉就可以了25.Struts2.0.14a)struts2.0.14中的spring-core-2.0.5.jar、spring-context-2.0.5.jar、spring-beans-2.0.5.jar、spring-web-2.0.5.jar与spring2.5.6中的spring.jar会冲突,应把spring-core-2.0.5.jar、spring-context-2.0.5.jar、spring-beans-2.0.5.jar、spring-web-2.0.5.jar删除。

spring2.5配置讲解

spring2.5配置讲解
这样以后要使用属性文件中的资源时,可以使用${属性名}来获得。
b、常用数据源的配置
第一种是:DBCP数据源,(需要加入2个jar文件,在spring中的lib下jakarta-commons/commons-dbcp.jar和
commons-pools.jar)主要配置如下:
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>classpath:com/baobaotao/place/jdbc.properties</value>
<property name="jndiName" value="java:comp/env/jdbc/bbt"/>
</bean>
从spring2.0开始提供jee命名空间,可以简化配置如下:
<jee:jndi-lookup id="dataSource" jndi-name="java:comp/env/jdbc/bbt"/>
</list>
</property>
<property name="fileEncoding" value="utf-8" />
</bean>
而在spring2.5的版本中提供了一种更简便的方式,如:

spring框架案例学习文档笔记

spring框架案例学习文档笔记

目录第一课:面向抽象编程 ....................................................................................... 3 第二课:Jdom 的基本使用 ..................................................................................... 3 第三课:模拟Spring 功能 .................................................................................... 4 第四课:搭建sping 的运行环境 . (7)一、 建立一个新的项目 ............................................................................. 7 二、 建立spring 的配置文件 ......................................................................... 7 三、 引入spring 的jar 包........................................................................... 7 四、 测试代码: ................................................................................... 7 五、 注意接口的使用: ............................................................................. 7 第五课:IOC(DI)配置及应用 . (8)一、 什么是IOC 、DI ................................................................................ 8 二、 编辑xml 文件时,没有提示 ...................................................................... 8 三、注入类型(Injecting dependencies) (8)(一) setter 注入类型Setter Injection .......................................................... 8 (二) 构造方法Constructor Injection (9)四、 id 、name .................................................................................... 10 五、 简单属性的注入 .............................................................................. 10 六、 Bean 的作用范围scope ......................................................................... 11 七、 集合注入 .................................................................................... 11 八、自动装配autowire (12)(一) byName .................................................................................. 12 (二) byType .................................................................................. 13 (三) 注意 .................................................................................... 13 九、生命周期 (14)(一) lazy-init/default-lazy-init ............................................................. 14 (二) init-method destroy-method 不要和prototype 一起用(了解) . (14)第六课:annotation 方式Spring (15)一、 开始使用annotation 配置Spring ............................................................... 15 二、@Autowired 、@Qualifier (15)(一) @Autowired .............................................................................. 15 (二) @Qualifier .............................................................................. 16 三、@Resource(重要、推荐) (16)(一) JSR-250 ................................................................................. 16 (二) @Resource . (16)四、 @Componet ................................................................................... 17 五、 @Scope 、@PostConstruct 、@PreDestroy .......................................................... 18 六、注解对应的jar 包 (18)第七课:AOP(面向切面编程) ..........................一、 AOP 概念 .............................二、 利用动态代理实现面向切面编程 19第八课:Spring AOP 配置选项 ........................一、 AOP 配置annotation 方式 ..............(一) 搭建annotation 开发环境 20(二)aspectJ 类库 .....................(三) AOP 的annotation 实例 ............(四)AspectJ 的专业术语 ...............Spring –SSH 整合 学习笔记---wjt276[2010-05-14](五) 织入点语法 (22)(六) Advice (23)(七) Pointcut (25)(八) annotatin方式的AOP实例 (25)二、AOP配置xml方式 (26)三、AOP实现动态代理注意 (27)第九课:DataSource (27)一、Sping配置数据源: (27)二、注入使用 (28)三、dbcp.BasicDataSource (28)第十课 Spring整合Hiberante3 (29)一、Spring配置hibernate3的SessionFactory (29)(一) xml形式的SessionFactory (29)(二) annotation注解方式的SessionFactory (29)二、引入hibernate所需要使用的jar (30)(一) 基本jar (30)(二) 加入annotation功能的jar包 (30)(三) 搭建日志环境并配置显示DDL语句jar包 (30)三、Spring整合hibernate3事务 (30)(一) Annotation注解方式配置事务管理 (30)(二) Spring事务选项 (34)(三) XML文件形式配置Spring事务管理 (36)四、HibernateTemplate (37)(一) HibernateTemplate (37)(二) HibernateDaoSupport (38)第十一课:Spring整合-SSH (39)一、第一步:加入jar包(需要的jar包列表) (39)二、第二步:首先整合Spring + Hibernate (40)三、第三步:再来整合Struts2 (40)四、struts的读常量: (42)第十二课:DTO、VO (42)一、DTO (42)二、VO (42)第十二课:SSH整合存在的问题 (42)一、Jsp中访问Session时,Session已经关闭 (42)二、如果不配置事务,openSessionView出现异常 (43)三、中文乱码问题: (43)第十三课:SSH整合的jar包 (44)一、Struts2 (44)二、Hibernate3.3.2 (44)三、Spring (45)第一课:面向抽象编程原来什么类都是写死的,现在是先建立一个大的标准,然后再各个实体类来实现他们的功能,然后在调用的时候,使用这个标准调用,这样,你们那个来都可以被调用。

Spring:Spring事务的4种特性、5种隔离级别、7种传播特性

Spring:Spring事务的4种特性、5种隔离级别、7种传播特性

Spring:Spring事务的4种特性、5种隔离级别、7种传播特性此⽂章只作笔记记录,不作为讲解⽂章1. 事务的特性(4种)原⼦性(atomicity):强调事务的不可分割.⼀致性(consistency): 事务的执⾏的前后数据的完整性保持⼀致.隔离性(isolation): 事务执⾏的过程中, 不受其他事务的⼲扰, 即并发执⾏的事物之间互不⼲扰持久性(durability) : 事务⼀旦结束, 数据就持久到数据库2. 事务诱发的问题2.1 脏读事务A读到了事务B的已操作但未提交的数据.2.2 不可重复读事务A有多次查询,第⼀次读取数据后继续运⾏,第⼆次读到了事务B已经提交的 update 的数据导致事务A 内的多次查询结果不⼀致.2.3 幻读事务A有多次查询,第⼀次读取数据后继续运⾏,第⼆次读到了事务B已经提交的 insert ( delete )的数据导致事务A 内的多次查询结果不⼀致.2.4 事务丢失( 回滚丢失 )事务A运⾏增删改操作后( 还未提交 ),事务B也运⾏增删改操作并提交,事务A继续运⾏后报错进⾏事务回滚时,此时就会把事务B的操作清除掉。

2.5 事务丢失( 提交丢失 )事务A与事务B同时对⼀组数据运⾏增删改操作,事务B先⼀步提交事务,事务A继续运⾏后也提交事务,此时就会把事务B的操作清除掉。

3. 数据库的事务隔离级别(4种)部分数据库的默认事务隔离级别为已提交读;例:SQL Server、OracleMysql的默认事务隔离级别为:可重复读4. 事务的隔离级别(5种)4.1 ISOLATION_DEFAULT 使⽤数据库默认的隔离级别4.2 ISOLATION_READ_UNCOMMITTED 事务最低的隔离级别 ( 可能会导致脏读,不可重复读,幻读 )4.3 ISOLATION_READ_COMMITTED 保证⼀个事务修改的数据提交后才能被另外⼀个事务读取 ( 可能会导致不可重复读,幻读 )4.4 ISOLATION_REPEATABLE_READ 保证⼀个事务修改的数据提交后才能被另外⼀个事务读取 ( 可能会导致幻读 ) 保证⼀个事务读取数据后,另外⼀个事务才能修改 ( 可能会导致幻读 )4.5 ISOLATION_SERIALIZABLE 这是花费最⾼代价但是最可靠的事务隔离级别。

Spring

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。

Spring 2.5新特性及架构图 独到讲解

Spring 2.5新特性及架构图 独到讲解

Spring 2.5新特性及架构图独到讲解【IT168 技术文档】Spring于10月22日推出2.5第一个发布候选版本(rc1),以下是对官方宣布文档做的摘要。

Spring2.5是Spring2.1各个里程碑版本的终结。

Spring2.5是对Spring2.0的增强,增加了一些新的特性:全面支持java6和javaEE5(JDBC 4.0, JTA 1.1, JavaMail 1.4, JAX-WS 2.0等)全特性的注释驱动依赖注入,包括对限定词的支持支持基于classpath的组件扫描,自动侦测有注释的类支持AspectJ切点表达式中包含bean name切点元素内置AspectJ加载时编织,星期8娱乐城 基于LoadTimeWeaver 提取更多的XML配置文件的名字空间支持,比如context和jms等,最大程度提高编写的方便性全面修订集成测试框架,支持JUnit4和TestNG新的基于注释的Servlet MVC和Portlet MVC控制器风格配置扩展SimpleJdbcTemplate功能,支持命名的参数等官方认可的Websphere支持,支持WebSphere 6 UOWManager 机制Spring框架的jar文件,兼容OSGi绑定,并能直接使用Spring ApplicationContext可被部署为JCA RAR文件,用于非主导应用模块JCA 1.5消息终端管理,用于Spring管理的JMS和CCI消息监听器有重要价值的特性为,天堂鸟娱乐城 基于注释的MVC控制器风格,JAX-WS 支持和TestNG支持。

另外,分发包有三种形式,增加了最小标准zip包和包含文档的zip包。

官方推荐升级所有2.0.x版本到2.5版本,因为可以从新特性中获益和显著提升性能。

Spring2.0可以简单的升级到2.5版本,只需替换相关jar文件。

Spring2.5仍然兼容JDK1.4.2+和J2EE1.3+。

Spring2.5注释语法(上)——Spring2.5注释驱动的IoC

Spring2.5注释语法(上)——Spring2.5注释驱动的IoC

Spring2.5注释语法(上)——Spring2.5注释驱动的IoC2008-10-22 23:05:26标签:Spring2.5Spring绝缘材料java javaEE版权声明:原创作品,如需转载,请与作者联系。

否则将追究法律责任。

Spring2.5注释语法(上)——Spring2.5注释驱动的IoC正如Spring框架的名称一样,它真的为我们JavaEE开发带来了一阵春风,而其著名的IoC (依赖注入)更是为它的经久不衰注入了无限活力。

在新发布的2.5版本中Spring的开发者为我们这些使用Java5或更高版本Java的开发人员提供了进一步简化而强大的新特性。

其中就包括了注释驱动的依赖性注入(annotation-driven dependency injection)和新的web控制器模型将请求映射到加注释的方法上,等等。

今天我首先要向大家介绍的就是Spring2.5中新特性之一---注释驱动的依赖性注入,在正式介绍之前我想先让大家了解一下什么是注释,请看下面的代码清单:一、了解Java注释代码清单1.1import ng.annotation.Retention;import ng.annotation.RetentionPolicy;@Retention(RetentionPolicy.RUNTIME)public @interface MyAnnotation {①定义一个注释int init();}代码清单1.2import ng.annotation.Annotation;public class TestAnnotation {@MyAnnotation(init = 2)②使用注释public void print(){System.out.println(TestAnnotation.class.getName());}public static void main(String[] args) throws Exception{ TestAnnotation ta = new TestAnnotation();Annotation[] annotations =ta.getClass().getMethod("print").getAnnotations();③for (Annotation annotation : annotations) { System.out.println("MyAnnotation.init : " +((MyAnnotation)annotation).init());④打印出init的值}}}在代码清单1.1中我们定义了一个名为MyAnnotation的注释而这个注释中只有一个类型为int名为init的属性,代码清单1.2中我们在②处使用了我们刚刚定义的注释并且为init赋值为2,在③处我们通过反射机制获得print方法上定义的所有注释然后通过迭代将其值init打印至控制台。

spring mvc

spring mvc

使用 Spring 2.5 基于注解驱动的Spring MVC陈雄华 (quickselect@), 技术总监, 宝宝淘网络科技有限公司简介:基于注解的配置有越来越流行的趋势,Spring 2.5 顺应这种趋势,为Spring MVC 提供了完全基于注解的配置。

本文将介绍 Spring 2.5 新增的 Sping MVC 注解功能,讲述如何使用注解配置替换传统的基于 XML 的 Spring MVC 配置。

概述继 Spring 2.0 对 Spring MVC 进行重大升级后,Spring 2.5 又为 Spring MVC 引入了注解驱动功能。

现在你无须让 Controller 继承任何接口,无需在 XML 配置文件中定义请求和 Controller 的映射关系,仅仅使用注解就可以让一个POJO 具有 Controller 的绝大部分功能——Spring MVC 框架的易用性得到了进一步的增强.在框架灵活性、易用性和扩展性上,Spring MVC 已经全面超越了其它的 MVC 框架,伴随着 Spring 一路高唱猛进,可以预见 Spring MVC 在 MVC 市场上的吸引力将越来越不可抗拒。

本文将介绍 Spring 2.5 新增的 Sping MVC 注解功能,讲述如何使用注解配置替换传统的基于 XML 的 Spring MVC 配置。

回页首一个简单的基于注解的 Controller使用过低版本 Spring MVC 的读者都知道:当创建一个 Controller 时,我们需要直接或间接地实现 org.springframework.web.servlet.mvc.Controller 接口。

一般情况下,我们是通过继承 SimpleFormController 或MultiActionController 来定义自己的 Controller 的。

在定义 Controller 后,一个重要的事件是在 Spring MVC 的配置文件中通过 HandlerMapping 定义请求和控制器的映射关系,以便将两者关联起来。

spring2.5 学习笔记

spring2.5 学习笔记

Spring –SSH整合学习笔记---wjt276[2010-05-14]目录第一课:面向抽象编程 (4)第二课:Jdom的基本使用 (4)第三课:模拟Spring功能 (5)第四课:搭建sping的运行环境 (8)一、建立一个新的项目 (8)二、建立spring的配置文件 (8)三、引入spring的jar包 (8)四、测试代码: (8)五、注意接口的使用: (8)第五课:IOC(DI)配置及应用 (9)一、什么是IOC、DI (9)二、编辑xml文件时,没有提示 (9)三、注入类型(Injecting dependencies) (9)(一) setter注入类型Setter Injection (9)(二) 构造方法Constructor Injection (10)四、id、name (11)五、简单属性的注入 (11)六、Bean的作用范围scope (12)七、集合注入 (12)八、自动装配autowire (13)(一) byName (13)(二) byType (14)(三) 注意 (14)九、生命周期 (15)(一) lazy-init/default-lazy-init (15)(二) init-method destroy-method 不要和prototype一起用(了解) (15)第六课:annotation方式Spring (16)一、开始使用annotation配置Spring (16)二、@Autowired、@Qualifier (16)(一) @Autowired (16)(二) @Qualifier (17)三、@Resource(重要、推荐) (17)(一) JSR-250 (17)(二) @Resource (17)四、@Componet (18)五、@Scope、@PostConstruct、@PreDestroy (19)六、注解对应的jar包 (19)第七课:AOP(面向切面编程) (19)一、AOP概念 (19)二、利用动态代理实现面向切面编程 (20)第八课:Spring AOP配置选项 (21)一、AOP配置annotation方式 (21)(一) 搭建annotation开发环境 (21)(二) aspectJ类库 (22)(三) AOP的annotation实例 (22)(四) AspectJ的专业术语 (23)(五) 织入点语法 (23)(六) Advice (24)(七) Pointcut (26)(八) annotatin方式的AOP实例 (26)二、AOP配置xml方式 (27)三、AOP实现动态代理注意 (28)第九课:DataSource (28)一、Sping配置数据源: (28)二、注入使用 (29)三、dbcp.BasicDataSource (29)第十课 Spring整合Hiberante3 (30)一、Spring配置hibernate3的SessionFactory (30)(一) xml形式的SessionFactory (30)(二) annotation注解方式的SessionFactory (30)二、引入hibernate所需要使用的jar (31)(一) 基本jar (31)(二) 加入annotation功能的jar包 (31)(三) 搭建日志环境并配置显示DDL语句jar包 (31)三、Spring整合hibernate3事务 (31)(一) Annotation注解方式配置事务管理 (31)(二) Spring事务选项 (35)(三) XML文件形式配置Spring事务管理 (37)四、HibernateTemplate (38)(一) HibernateTemplate (38)(二) HibernateDaoSupport (39)第十一课:Spring整合-SSH (40)一、第一步:加入jar包(需要的jar包列表) (40)二、第二步:首先整合Spring + Hibernate (41)三、第三步:再来整合Struts2 (41)四、struts的读常量: (43)第十二课:DTO、VO (43)一、DTO (43)二、VO (43)第十二课:SSH整合存在的问题 (43)一、Jsp中访问Session时,Session已经关闭 (43)二、如果不配置事务,openSessionView出现异常 (44)三、中文乱码问题: (44)第十三课:SSH整合的jar包 (45)一、Struts2 (45)二、Hibernate3.3.2 (45)三、Spring (46)第一课:面向抽象编程原来什么类都是写死的,现在是先建立一个大的标准,然后再各个实体类来实现他们的功能,然后在调用的时候,使用这个标准调用,这样,你们那个来都可以被调用。

相关主题
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

Spring2.5的新特性:第一部分作者Mark Fisher译者沙晓兰发布于2008年1月7日下午7时43分社区Java主题Web框架标签Spring框架简介从诞生之初,Spring框架就坚守它的宗旨:简化企业级应用开发,同时给复杂问题提供强大的、非侵入性解决方案。

一年前发布的Spring2.0就把这些主题推到了一个新的高度。

XML Schema的支持和自定义命名空间的使用大大减少了基于XML的配置。

使用Java5及更新版本java的开发人员如今可以利用植入了像泛型(generic)和注解等新语言特性的Spring库。

最近,和AspectJ表达式语言的紧密集成,使得以非侵入方式添加跨越定义良好的Spring管理对象分组的行为成为可能。

新发布的Spring2.5继续坚持了这个发展趋向,特别是为那些使用Java5或更新版本java的开发人员提供了进一步简化而强大的新特性。

这些新特性包括:注解驱动的依赖性注入(annotation-driven dependency injection),使用注解而非XML元数据来自动侦测classpath上的Spring组件,注解对生命周期方法的支持,一个新的web控制器模型将请求映射到加注解的方法上,在测试框架中支持Junit4,Spring XML命名空间的新增内容,等等。

本文是探讨这些新特性的3篇系列文章中的第一篇。

本文将主要关注于简化的配置和在Spring应用程序上下文(application context)核心新增的基于注解的功能;第二篇文章将涵盖web层可用的新特性;最后一篇文章将着重介绍集成和测试的新增性能。

这一系列的三篇文章中引用的例子都基于Spring PetClinic 应用程序范例。

此范例最近被重构以用于展示Spring最新功能,并被包含于Spring 2.5的发布下载包中,可以从Spring Framework下载网页下载。

查看"samples/petclinic"目录下的"readme.txt"文件可以得知关于如何构建和部署PetClinic应用程序,掌握本文提到的新技术的最佳方法也许就是对PetClinic 应用程序中所展示的特性进行试验。

Spring支持JSR-250注解Java EE5中引入了“Java平台的公共注解(Common Annotations for the Java Platform)”,而且该公共注解从Java SE6一开始就被包含其中。

2006年5月,BEA系统宣布了他们在一个名为Pitchfork的项目上与Interface21的合作,该项目提供了基于Spring的Java EE5编程模型的实现,包括支持用于注入(injection)、拦截(interception)和事务处理(transactions)的JSR-250注解和EJB3注解(JSR-220)。

在2.5版本中,Spring框架的核心(core)现在支持以下JSR-250注解:•@Resource•@PostConstruct•@PreDestroy结合Spring,这些注解在任何开发环境下都可以使用——无论是否有应用程序服务器——甚至是集成测试环境都可以。

激活这样的支持仅仅是注册一个单独的Spring post-processor的事情:<beanclass="monAnnotationBeanPos tProcessor"/>@Resource注解@Resource注解被用来激活一个命名资源(named resource)的依赖注入,在JavaEE应用程序中,该注解被典型地转换为绑定于JNDI context中的一个对象。

Spring确实支持使用@Resource通过JNDI lookup来解析对象,默认地,拥有与@Resource注解所提供名字相匹配的“bean name(bean名字)”的Spring管理对象会被注入。

在下面的例子中,Spring会向加了注解的setter方法传递bean 名为“dataSource”的Spring管理对象的引用。

@Resource(name="dataSource")public void setDataSource(DataSource dataSource){this.dataSource=dataSource;}直接使用@Resource注解一个域(field)同样是可能的。

通过不暴露setter方法,代码愈发紧凑并且还提供了域不可修改的额外益处。

正如下面将要证明的,@Resource注解甚至不需要一个显式的字符串值,在没有提供任何值的情况下,域名将被当作默认值。

@Resourceprivate DataSource dataSource;//inject the bean named'dataSource'该方式被应用到setter方法的时候,默认名是从相应的属性衍生出来,换句话说,命名为'setDataSource'的方法被用来处理名为'dataSource'的属性。

private DataSource dataSource;@Resourcepublic void setDataSource(DataSource dataSource){this.dataSource=dataSource;}当@Resource没有显式提供名字的时候,如果根据默认名字找不到对应的Spring 管理对象,注入机制会回滚至类型匹配(type-match)。

如果刚好只有一个Spring 管理对象符合该依赖的类型,那么它会被注入。

通过设置CommonAnnotationBeanPostProcessor的‘fallbackToDefaultTypeMatch’属性为“false”(默认值是“true”)可以禁用这一特性。

<beanclass="monAnnotationBeanPos tProcessor"><property name="fallbackToDefaultTypeMatch"value="false"/></bean>正如上文所提到的,在解析标有@Resource注解的依赖时,Spring支持JNDI-lookup。

如若要强制对所有使用@Resource注解的依赖进行JNDI lookup,那也只要将CommonAnnotationBeanPostProcessor的'alwaysUseJndiLookup'标识设置为true就可以了(默认值是false)。

<beanclass="monAnnotationBeanPos tProcessor"><property name="alwaysUseJndiLookup"value="true"/></bean>另一个选择是,激活指定为‘resource-ref-mappings’的依据全局JNDI名的查找,在@Resource注解内提供‘mappedName’属性。

即使目标对象实际上是一个JNDI资源,仍然推荐引入一个Spring管理对象,这样可以提供一个间接层并且因此降低耦合程度。

自Spring2.0开始添加命名空间以来,定义一个委托Spring 处理JNDI lookup的bean也变得愈发简练:<jee:jndi-lookup id="dataSource"jndi-name="java:comp/env/jdbc/petclinic"/>这个方法的优点在于间接层带来了巨大的部署弹性。

比如说,一个单独的系统测试环境应该不再需要JNDI注册。

在这种情况下,在系统测试配置中可以提供如下的bean定义:<bean id="dataSource"class="org.springframework.jdbc.datasource.DriverManagerDataSource"p:driverClassName="${jdbc.driverClassName}"p:username="${ername}"p:password="${jdbc.password}"/>顺便提一下,上面的例子中,实际的JDBC连接属性从一个属性文件(properties file)解析而来,在这个属性文件里,关键字与提供的${占位符}互相对应,这需要注册一个名为PropertyPlaceholderConfigurer的BeanFactoryPostProcessor实现来完成。

这是具体化那些属性(通常是针对特定环境的属性)常用的技术,这些属性可能比其他配置修改得更为频繁。

<beanclass="org.springframework.beans.factory.config.PropertyPlaceholderCo nfigurer"><property name="location"value="classpath:jdbc.properties"/></bean>Srping2.5中新加入了‘context’命名空间,这个命名空间让我们能够得到更为简洁的方式来实现属性占位符(property placeholder)的配置:<context:property-placeholder location="classpath:jdbc.properties"/>生命周期注解:@PostConstruct和@PreDestroy@PostConstruct和@PreDestroy注解分别用来触发Spring的初始化和销毁回调。

这个特性在原有基础上得到了扩展,但并没有替代在Spring2.5之前版本中提供的同样的回调的另两个选项。

第一个选项是实现Spring的InitializingBean和DisposableBean接口中的一个或两个。

这两个接口都需要一个回调方法的实现(分别是afterPropertiesSet()和destroy())。

这种基于接口的方法利用了Spring自动识别任何实现这些接口的Spring管理对象的能力,因而不再需要另外的配置。

相关文档
最新文档