黑马程序员：三大框架11天笔记全之Spring-day10笔记

黑马程序员_javaweb讲义和笔记资料一、简介黑马程序员是一家专业的IT培训机构，提供全面的编程技术培训服务。

javaweb是其中的一门重要课程，本文为黑马程序员_javaweb讲义和笔记的资料整理。

二、javaweb基础知识1. Java语言概述Java语言的特点和优势，Java开发环境的搭建等。

2. Servlet技术Servlet的基本概念、生命周期、Servlet容器等。

3. JSP技术JSP的基本语法、JSP指令、JSP内置对象等。

4. MVC设计模式MVC设计模式在javaweb开发中的应用和实践。

三、javaweb开发流程1. 需求分析分析项目需求，明确开发目标和功能要求。

2. 数据库设计设计数据库表结构，确定数据存储方式和关系。

3. 技术选型根据项目需求和开发要求，选择合适的技术框架和工具。

4. 编码实现使用Java语言和相关技术进行编码实现。

5. 测试调试运行和调试项目，确保功能的正确性和稳定性。

6. 部署上线将项目部署到服务器上线，提供给用户访问和使用。

四、javaweb开发常用框架和工具1. Spring框架Spring框架的介绍和核心特性，以及在javaweb开发中的应用。

2. SpringMVC框架SpringMVC框架的详细讲解，包括请求映射、数据绑定、视图解析等。

3. MyBatis框架MyBatis框架的使用方法和技巧，以及与数据库的集成。

4. Maven工具Maven的基本使用和配置，常用插件介绍。

五、javaweb开发中的常见问题和解决方案1. 数据库连接异常分析数据库连接异常的原因和解决方法。

2. 页面跳转问题页面跳转的实现方式和常见错误排查。

3. 表单数据验证表单数据验证的常用技术和插件，提高数据输入的准确性和安全性。

4. 性能优化优化javaweb应用的性能，减少响应时间和资源占用。

六、实例项目提供一个实例项目，通过对该项目的讲解和分析，帮助学员理解和掌握javaweb开发的方法和技巧。

黑马程序员：三大框架11天笔记全之hibernate-day06笔记黑马程序员：三大框架hibernate-day06笔记第1章Hibernate持久化类与主键生成策略1.1Hibernate持久化类什么是持久化类?Persistent Object （PO）PO=POJO+hbm映射配置对于hibernate中的PO编写规则:1.必须提供一个无参数的public构造方法2.所有属性要private ,对外提供public 的get/set方法3.在PO类必须提供一个标识属性，让它与数据库中的主键对应，我们管这个属性叫OID4.PO类中的属性尽量使用基本数据类型的包装类.Int-→Integer double--→Double float-→Float5.PO类它不能使用final修饰符OID作用:OID指的是与数据库中表的主键对应的属性。

Hibernate框架它是通过OID来区分不同的PO对象，如果在内存中有两个相同的OID对象，那么hibernate认为它们是同一个对象。

为什么PO类属性它要使用包装类型?使用基本数据类型是没有办法去描述不存在概念，如果使用包装类型，它就是一个对象，对于对象它的默认值是null.PO类不可以使用final修饰?(hibernate中的get/load方法的区别)Get/load方法它们都是根据id去查询对象。

1.get直接得到了一个持久化类型对象，它就是立即查询操作load它得到的是持久化类开的代理类型对象（子类对象）。

它采用了一种延迟策略来查询数据。

2.get方法在查询时，如果不存在返回nullload方法在查询时，如果不存在，会产生异常ObjectNotFoundException.1.2Hibernate主键生成策略Hibernate中定义的主键类型包括：自然主键和代理主键：自然主键：具有业务含义字段作为主键，比如：学号、身份证号代理主键：不具有业务含义字段作为主键（例如自增id），比如：mysql自增主键，oracle序列生成的主键、uuid()方法生成的唯一序列串建议：企业开发中使用代理主键！第2章Hibernate持久化对象状态2.1持久化对象三种状态有三种:1.瞬时态：也叫做临时态或自由态，它一般指我们new出来的对象，它不存在OID,与hibernate session无关联，在数据库中也无记录。

黑马程序员：三大框架Spring-day09笔记Bean的属性注入在spring中bean的属性注入有两种1.1构造器注入1.2Setter方法注入关于ref属性作用使用ref来引入另一个bean对象，完成bean之间注入1.3集合属性的注入在spring中对于集合属性，可以使用专门的标签来完成注入例如:list set map properties等集合元素来完成集合属性注入.1.3.1List属性注入如果属性是数组类型也可以使用list完成注入1.3.2Set属性注入1.3.3Map属性注入1.3.4Properties属性注入Java.util.Properties是java.utilsMap的实现类，它的key与value都是String类型.1.4名称空间p和c的使用Spring2.0以后提供了xml命名空间。

P名称空间C名称空间首先它们不是真正的名称空间，是虚拟的。

它是嵌入到spring内核中的。

使用p名称空间可以解决我们setter注入时<property>简化使用c名称空间可以解决我们构造器注入时<constructor-arg>简化使用setter注入在applicationContext.xml文件中添加p名称空间简化setter注入使用c名称空间来解决构造器注入在applicationContext.xml文件中添加c名称空间注：如果c或p名称空间操作的属性后缀是”-ref”代表要引入另一个已经存在的bean,例如1.5SpElspring expression language 是在spring3.0以后的版本提供它类似于ognl或el表达式，它可以提供在程序运行时构造复杂表达式来完成对象属性存储及方法调用等。

Spel表达式的格式#{表达式}示例1：完成bean之间的注入示例2 支持属性调用及方法调用第2章Spring注解开发在spring中使用注解，我们必须在applicationContext.xml文件中添加一个标签<context:annotation-config/>作用是让spring中常用的一些注解生效。

【黑马程序员】JavaEE框架：spring（一）一、技术说明（技术介绍，技术优势以及发展史等）1.1、什么是springl Spring是分层的JavaSE/EE full-stack 轻量级开源框架分层：三层体系结构，为每一个层都提供解决方案web层：struts2、spring-mvcservice层：springdao层：hibernate、mybatis、jdbcTemplate(spring)轻量级：使用时占用资源少，依赖程序少。

比较：EJB1.2、spring由来Expert One-to-One J2EE Design and Development ，介绍EJB，使用，特点Expert One-to-One J2EE Development without EJB ，不使用EJB，spring思想1.3、spring核心l 以IoC（Inverse of Control 反转控制）和AOP（Aspect Oriented Programming 面向切面编程为内核）1.4、spring优点l 方便解耦，简化开发（易扩展，易维护）•Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给Spring管理l AOP编程的支持•Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能l 声明式事务的支持•只需要通过配置就可以完成对事务的管理，而无需手动编程l 方便程序的测试•Spring对Junit4支持，可以通过注解方便的测试Spring程序l 方便集成各种优秀框架•Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持l 降低JavaEE API的使用难度•Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低1.5、spring体系结构l spring 核心功能：beans 、core 、context 、expression二、环境搭建（技术开发环境）2.1、获取 Spring framework jar 包 1、spring 官网下载从官网下载spring 最新的相关jar 包，官网download 地址/springcommunity-download下载完成后会发现三个目录，命名很明确。

黑马程序员：三大框架Spring-day11笔记Spring事务管理机制Spring事务管理的四个优点:1.提供一致的对于不同的事务管理的API2.支持声明式事务管理(重点)3.编程事务管理(在开发中应用比较少)4.优秀的整合与Spring的数据访问我们重点讲解spring的事务管理的相关的API，还有声明式事务管理Spring事务管理主要提供了三个接口来完成.springframework.transaction.PlatformTransactionManager这是一个事务管理器，可以来选择相关的平台(jdbc hibernate jpa…)2.TransactionDefinition它定义事务的一些相关信息例如隔离传播超时只读3.TransactionStatus它主要描述事务具体的运行状态1.1.1PlatformTransactionManager平台事务管理器在不同的持久化层解决技术它的事务代码不一样。

JDBC开发Connection con=……;con.setAutoCommit(false);//开启事务con.rollback();mit();Hibernate开发Session session=….;Transaction t=session.beginTransaction();mit();t.rollback();PlatformTransactionManager接口APIDataSourceTransactionManager 主要针对于JdbcTemplate开发MyBatis开发HibernateTransactionManasger主要针对于Hibernate开发JpaTransactionManager 主要针对于JPA开发。

1.1.2TransactionDefinition它描述的是事务的定义信息。

在TransactionDefinition中定义了大量的常量1.1.2.1隔离以下是关于隔离性相关信息事务的四个特性ACID 原子性一致性隔离性持久性。

s Spring培训学习笔记spring概述.................................................. 错误!未定义书签。

控制反转，还是依赖注入................................... 错误!未定义书签。

面向方面编程............................................. 错误!未定义书签。

一致性抽象............................................... 错误!未定义书签。

事务管理................................................. 错误!未定义书签。

测试..................................................... 错误!未定义书签。

与其它框架整合........................................... 错误!未定义书签。

控制反转..................................................... 错误!未定义书签。

容器(container) .......................................... 错误!未定义书签。

IoC类型................................................. 错误!未定义书签。

IoC in spring ............................................ 错误!未定义书签。

DI with spring ........................................... 错误!未定义书签。

AOP ......................................................... 错误!未定义书签。

黑马程序员总体学习情况和学习计划安排期待与您交流! 从刚开始接触黑马，然后离职学习到现在已经一个月过去了，时间过得很快，但是在这段时间里感觉很充实。

从接触黑马的那时候起，我就开始从黑马论坛上下视频，然后每天下班后学习，渐渐地它已经成为我工作生活的一部分了。

黑马之所以吸引我，不仅仅由于它的零学费入学的商业模式、更高的职业预期，更重要的是让我发现有一个能够让我挥洒全部的激情、精力，并在其中收获更大成就感的的一个事业-编程。

我想，每一个程序员最大的满足不仅仅在于金钱的回报，那种自己的劳动成果被大家认可的成就感是金钱所无法比拟的，这个才是最大的满足吧。

由于之前一段时间是在职学习的缘故，所以毕老师的25天基础视频昨天看完，毕老师上班上课幽默之中带着几分严谨，许多问题都讲的很透彻，非常适合刚入门的战友，对我的学习帮助很大，在这里赞一个嘿嘿。

现在稍微总结一下，看完视频后的体会，具体的学习日志将在后续的文章中进行总结。

有的人认为计算机是个很神秘的东西，看完视频后我倒是不这样觉得了。

我的理解是其实计算机也和其他东西一样，是人与人之间沟通的媒介，程序员和程序员，程序员和用户等都是通过这个媒介进行着思想的交流，从人到计算机，再从计算机到人，这里面都是个沟通过程，程序员将自己的思想通过代码的形式传递给计算机，与计算机进行沟通，然后计算机在获得其他人的使用体验后进行反馈，与其他媒介不同的是，这两个过程都要以计算机的能够识别的方式才能完成，也即计算机语言。

学习完25天的基础视频，在毕老师的多次形象化举例下，我发现原来计算机语言，也包含着许多生活中的东西，它作为一种逻辑语言，其他也包含很多生活中的逻辑。

从这一点看，它就不是那么难理解了。

了解了语法基础，接下来就是面向对象这个思想的理解了，面向对象做为java的特点之一，贯穿了后面知识的整个学习过程，包括继承、多线程、集合、IO、GUI、网络编程等，可以说它是无处不在。

理解了它是学习其他知识的基础。

说明笔记中每个知识点均标有如下标识中的一个或多个，释义如下：理解要求：了解：了解本知识点，明确本知识点的作用理解：理解本知识点所涉及内容的工作原理操作要求：操作：根据本知识点所涉及的内容，进行课堂案例的制作应用：根据本知识点所涉及的内容，进行融会贯通，灵活应用知识点相关：重点：本知识点为本课程重点内容难点：本知识点为本课程难点内容，理解难度较高（难点不一定是重点）目录spring简介【了解】 (3)资源包整理【了解】【应用】 (4)IoC【理解】【应用】【重点】 (5)DI【理解】【应用】【重点】 (7)BeanFactory【了解】 (8)Bean配置（XML）【理解】【应用】【重点】 (9)团队开发【了解】【操作】 (13)Bean配置（注解）【了解】【操作】 (14)Spring整合JUnit【了解】【操作】 (16)AOP简介【理解】【重点】 (17)AOP简介【理解】【重点】 (17)AOP基本概念【理解】【重点】 (18)AOP（XML）【理解】【应用】【重点】 (19)AOP（注解）【理解】【应用】【重点】 (24)CGLIB【理解】【难点】 (25)DAO模板类【了解】 (26)DAO支持抽象类【理解】【操作】 (29)事务管理基本概念【了解】 (31)声明式事务（XML）【理解】【重点】 (34)声明式事务（注解）【理解】【应用】【重点】 (36)SSH整合（XML）【理解】【应用】【重点】 (37)Hibernate模板类【理解】【应用】【重点】 (42)spring简介【了解】1.Spring是一个基于Java的轻量级的J2EE框架基于Java: 底层Java实现轻量级：性能较高，运行速度较快，内存消耗较少重量级组件：EJB、CGIJ2EE应用框架:Spring可以在JEE开发的三层架构的每一层为开发者带来帮助表现层：Servlet/JSP，Struts2，SpringMVC业务层：Bean管理、AOP、事务管理数据层：JDBC，Hibernate，Spring JDBCTemplate域模型层：实体类+DAO服务层：远端调用（webservice）[类似技术RMI+JNDI]Spring提供的每层的服务技术表现层：String MVC业务逻辑层：Bean管理、AOP、事务管理数据层：DAO支持抽象类，DAO模板技术JDBCTemplate2. Spring的发展历程创始人：Rod JohnsonExpert One-to-One J2EE Design and Development(2002)阐述了J2EE使用EJB开发设计的优点及解决方案Expert One-to-One J2EE Development without EJB(2004)阐述了J2EE开发过程中不使用EJB的解决方式(Spring雏形)3.Spring核心技术IOC:控制反转AOP:面向切面编程/面向方面编程4.Spring是一个超级的“黏合平台”，将很多技术黏合在一起，形成一个整体，使每个组件发挥其最大功效资源包整理【了解】【应用】1.本课程基于Spring3.2.0进行讲解2.下载地址：/release/org/springframework/spring/说明：通过Maven部署资源从仓库获取（后期课程）3.资源文件Spring资源包下spring-framework-3.2.0.RELEASE-dist.zipSpring依赖资源包spring-framework-3.0.2.RELEASE-dependencies.zip4.资源包目录层次结构docs:API帮助文档与官方手册libs:开发使用的jar包schema:开发使用的XML约束文档源文件5.开发jar包核心jar(4个)spring-beans-3.2.0.RELEASE.jarspring-context-3.2.0.RELEASE.jarspring-core-3.2.0.RELEASE.jarspring-expression-3.2.0.RELEASE.jar日志相关jar(2个)commons-logging-1.1.1.jarcommons-logging日志整合，与slf4j类似，由apache提供log4j-1.2.15.jarIoC【理解】【应用】【重点】1.IoC(Inversion of Control)控制反转A:控制：控制的双方是什么？谁控制谁？主控方：Spring被控方：应用程序所使用的资源(原始)应用程序控制自己执行操作需要使用的外部资源(Spring)Spring控制整个程序中所需要使用的外部资源B.反转：什么是反转？反转什么？正向：应用程序直接调用资源反向：应用程序依赖Spring为其提供资源反转的是资源的控制权应用程序由主动调用资源，变为被动的等待Spring提供资源C.有什么好处？正向缺点：应用程序控制的资源分布在程序的每一个地方反向的优点：所有的资源都在Spring中，便于管理总结：Spring反向控制应用程序所需要使用的外部资源。

Spring部分学习笔记讲师:梁建全liangjq@目录Spring部分学习笔记 (1)DAY01 (5)一、Spring框架的作用和好处 (5)二、Spring框架对Bean组件的管理 (5)1、使用方法： (5)2、Spring容器对Bean组件的管理 (5)3、Spring框架的IoC机制 (6)A.DI (依赖注入) (6)B.各种类型数据的注入 (7)C.IoC(Inverse of Controller,控制反转) (9)三、AOP概念 (9)1、什么是AOP? (9)2、AOP基本应用 (9)A.引入AOP开发包 (9)B.定义一个Bean组件(方面组件)，封装共通处理 (9)C.在applicationContext.xml中定义AOP配置 (9)3、AOP相关概念 (10)4、通知类型 (10)5、切入点表达式 (11)6、AOP练习完成记录用户操作日志示例。

(11)7、编写一个AOP示例，异常处理方面 (13)DAY02 (14)一、Log4j工具介绍 (14)1、体系结构 (14)2、消息级别 (14)二、Spring注解配置 (15)1、组件的自动扫描 (15)2、AOP注解标记 (15)3、(异常处理)案例重构 (15)4、XML和注解两种配置形式 (16)DAY03 (17)一、Spring对数据访问层的支持 (17)1、提供了事务管理 (17)2、提供了DAO实现支持 (17)3、如何整合JDBC技术 (17)4、如何整合Hibernate技术 (19)5、Spring整合Hibernate后，如何使用Hibernate中的Session对象 (21)二、Spring如何与Struts2框架整合 (22)1、添加Struts2框架 (22)2、编写Action，需要使用DAO组件采用DI方式注入 (22)3、Spring容器中定义Action组件，注入DAO (22)4、在struts.xml中定义Action组件和请求配置 (22)5、在web.xml中添加配置，在启动tomcat时，实例化Spring容器 (23)DAY04 (24)一、Spring与Struts2、Hibernate 整合 (24)1、SSH工作流程 (24)二、ssh开发步骤 (25)1、引入开发包 (25)2、编写实体类和映射文件hbm.xml(可以利用MyEclipse工具) (25)3、编写DAO组件 (26)4、在Spring配置文件中定义DAO,SessionFactory,DataSource按以下关系注入 (26)5、添加Struts2配置文件及控制器配置 (27)6、编写Action组件,需要使用Service或DAO时，采用名称匹配规则注入 (27)7、在struts.xml中添加Action组件配置（代码在5、中） (27)8、修改jsp，利用struts2标签完成显示 (27)9、修改web.xml，添加Listener配置，实例化Spring容器 (27)10、按ssh-2图示检查一下流程。

课程内容1.面向接口（抽象）编程的概念与好处2.IOC/DI的概念与好处a)inversion of controlb)dependency injection3.AOP的概念与好处4.Spring简介5.Spring应用IOC/DI（重要）a)xmlb)annotation6.Spring应用AOP（重要）a)xmlb)annotation7.Struts2.1.6 + Spring2.5.6 + Hibernate3.3.2整合（重要）a)opensessionInviewfilter（记住，解决什么问题，怎么解决）8.Spring JDBC面向接口编程（面向抽象编程）1.场景：用户添加2.Spring_0100_AbstractOrientedProgramminga)不是AOP:Aspect Oriented Programming3.好处：灵活什么是IOC（DI），有什么好处1.把自己new的东西改为由容器提供a)初始化具体值b)装配2.好处：灵活装配Spring简介1.项目名称：Spring_0200_IOC_Introduction2.环境搭建a)只用IOCi.spring.jar , jarkata-commons/commons-loggin.jar3.IOC容器a)实例化具体beanb)动态装配4.AOP支持a)安全检查b)管理transactionSpring IOC配置与应用1.FAQ:不给提示：a)window – preferences – myeclipse – xml – xml catalogb)User Specified Entries – addi.Location: D:\share\0900_Spring\soft\spring-framework-2.5.6\dist\resources\spring-beans-2.5.xsdii.URI:file:///D:/share/0900_Spring/soft/spring-framework-2.5.6/dist/resources/spring-beans-2.5.xsd iii.Key Type: Schema Locationiv.Key: /schema/beans/spring-beans-2.5.xsd2.注入类型a)Spring_0300_IOC_Injection_Typeb)setter（重要）c)构造方法（可以忘记）d)接口注入（可以忘记）3.id vs. namea)Spring_0400_IOC_Id_Nameb)name可以用特殊字符4.简单属性的注入a)Spring_0500_IOC_SimplePropertyb)<property name=… value=….>5.<bean 中的scope属性a)Spring_0600_IOC_Bean_Scopeb)singleton 单例c)proptotype 每次创建新的对象6.集合注入a)Spring_0700_IOC_Collectionsb)很少用，不重要！参考程序7.自动装配a)Spring_0800_IOC_AutoWireb)byNamec)byTyped)如果所有的bean都用同一种，可以使用beans的属性：default-autowire8.生命周期a)Spring_0900_IOC_Life_Cycleb)lazy-init (不重要)c)init-method destroy-methd 不要和prototype一起用（了解）9.Annotation第一步：a)修改xml文件，参考文档<context:annotation-config />10.@Autowireda)默认按类型by typeb)如果想用byName，使用@Qulifierc)写在private field（第三种注入形式）（不建议，破坏封装）d)如果写在set上，@qualifier需要写在参数上11.@Resource（重要）a)加入：j2ee/common-annotations.jarb)默认按名称，名称找不到，按类型c)可以指定特定名称d)推荐使用e)不足：如果没有源码，就无法运用annotation，只能使用xml12.@Component @Service @Controller @Repositorya)初始化的名字默认为类名首字母小写b)可以指定初始化bean的名字13.@Scope14.@PostConstruct = init-method; @PreDestroy = destroy-method; 什么是AOP1.面向切面编程Aspect-Oriented-Programminga)是对面向对象的思维方式的有力补充2.Spring_1400_AOP_Introduction3.好处：可以动态的添加和删除在切面上的逻辑而不影响原来的执行代码a)Filterb)Struts2的interceptor4.概念：a)JoinPoint 释意:切面与原方法交接点即切入点b)PointCut 释意:切入点集合c)Aspect（切面）释意:可理解为代理类前说明d)Advice 释意:可理解为代理方法前说明例如@Beforee)Target 释意:被代理对象被织入对象f)Weave 释意:织入Spring AOP配置与应用1.两种方式：a)使用Annotationb)使用xml2.Annotationa)加上对应的xsd文件spring-aop.xsdb)beans.xml <aop:aspectj-autoproxy />c)此时就可以解析对应的Annotation了d)建立我们的拦截类e)用@Aspect注解这个类f)建立处理方法g)用@Before来注解方法h)写明白切入点（execution …….）i)让spring对我们的拦截器类进行管理@Component3.常见的Annotation:a)@Pointcut 切入点声明以供其他方法使用, 例子如下:@Aspect@Componentpublic class LogInterceptor {@Pointcut("execution(public * com.bjsxt.dao..*.*(..))")public void myMethod(){}@Around("myMethod()")public void before(ProceedingJoinPoint pjp) throws Throwable{System.out.println("method before");pjp.proceed();}@AfterReturning("myMethod()")public void afterReturning() throws Throwable{System.out.println("method afterReturning");}@After("myMethod()")public void afterFinily() throws Throwable{System.out.println("method end");}}b)@Before 发放执行之前织入c)@AfterReturning 方法正常执行完返回之后织入(无异常)d)@AfterThrowing 方法抛出异常后织入e)@After 类似异常的finallyf)@Around 环绕类似filter , 如需继续往下执行则需要像filter中执行FilterChain.doFilter(..)对象一样执行ProceedingJoinPoint.proceed()方可,例子如下:@Around("execution(* com.bjsxt.dao..*.*(..))")public void before(ProceedingJoinPoint pjp) throws Throwable{System.out.println("method start");pjp.proceed();//类似FilterChain.doFilter(..)告诉jvm继续向下执行}4.织入点语法a)void !voidb)参考文档（* ..）如果execution(* com.bjsxt.dao..*.*(..))中声明的方法不是接口实现则无法使用AOP实现动态代理,此时可引入包” cglib-nodep-2.1_3.jar”后有spring自动将普通类在jvm中编译为接口实现类,从而打到可正常使用AOP的目的.5.xml配置AOPa)把interceptor对象初始化b)<aop:configi.<aop:aspect …..1.<aop:pointcut2.<aop:before例子：<bean id="logInterceptor" class="com.bjsxt.aop.LogInterceptor"></bean><aop:config><!-- 配置一个切面 --><aop:aspect id="point" ref="logInterceptor"><!-- 配置切入点，指定切入点表达式 --><!-- 此句也可放到 aop:aspect标签外依然有效--><aop:pointcutexpression="execution(public * com.bjsxt.service..*.*(..))"id="myMethod" /><!-- 应用前置通知 --><aop:before method="before" pointcut-ref="myMethod" /><!-- 应用环绕通知需指定向下进行 --><aop:around method="around" pointcut-ref="myMethod" /><!-- 应用后通知 --><aop:after-returning method="afterReturning"pointcut-ref="myMethod" /><!-- 应用抛出异常后通知 --><aop:after-throwing method="afterThrowing"pointcut-ref="myMethod" /><!-- 应用最终通知 --><aop:after method="afterFinily"pointcut="execution(public * om.bjsxt.service..*.*(..))" /></aop:aspect></aop:config>Spring整合Hibernate1.Spring 指定datasourcea)参考文档，找dbcp.BasicDataSourcei.c3p0ii.dbcpiii.proxoolb)在DAO或者Service中注入dataSourcec)在Spring中可以使用PropertyPlaceHolderConfigure来读取Properties文件的内容2.Spring整合Hibernatea)<bean .. AnnotationSessionFactoryBean>i.<property dataSourceii.<annotatedClassesb)引入hibernate 系列jar包c)User上加Annotationd)UserDAO或者UserServie 注入SessionFactorye)jar包问题一个一个解决3.声明式的事务管理a)事务加在DAO层还是Service层？b)annotationi.加入annotation.xsdii.加入txManager beaniii.<tx:annotation-driven例如: <bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory"><ref bean="sessionFactory" /></property></bean><tx:annotation-driven transaction-manager="transactionManager"/> iv.在需要事务的方法上加：@Transactionalv.需要注意，Hibernate获得session时要使用SessionFactory.getCurrentSession 不能使用OpenSessionc)@Transactional详解i.什么时候rollback1.运行期异常，非运行期异常不会触发rollback2.必须uncheck (没有catch)3.不管什么异常，只要你catch了，spring就会放弃管理4.事务传播特性：propagation_required例如: @Transactional(propagation=Propagation.REQUIRED)等同于(@Transactional)作用,一个方法声明了@Transactional事务后,其内再调用的方法不需要再声明@Transactional.5.read_only例如: @Transactional(propagation=Propagation.REQUIRED,readOnly=true)当方法声明readOnly=true时,该方法及其调用的方法内都不执行insert update等d)xml（推荐，可以同时配置好多方法）i.<bean txmanagerii.<aop:config1.<aop:pointcut2.<aop:advisor pointcut-ref advice-refiii.<tx:advice: id transaction-manager =iv.<property name="packagesToScan"> 可定义扫描目标包下所有实体类例如: <bean id="sessionFactory"class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"><property name="dataSource" ref="dataSource" /><property name="hibernateProperties"><props><prop key="hibernate.dialect">org.hibernate.dialect.OracleDialect</prop> <prop key="hibernate.show_sql">true</prop></props></property><!--<property name="annotatedClasses"><list><value>com.bjsxt.model.TestUser</value><value>com.bjsxt.model.Log</value></list></property>--><!-- 将参数名称设为packagesToScan 可定义扫描目标包下所有实体类--><property name="packagesToScan"><list><value>com.bjsxt.model</value></list></property></bean>//事务管理@transactional的注入<bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory"><ref bean="sessionFactory" /></property></bean>//定义字符串“execution（）”为一个变量名，简化<aop:config><aop:pointcutexpression="execution(public * com.bjsxt.service..*.*(..))"id="myServiceMethod" /><aop:advisor pointcut-ref="myServiceMethod" advice-ref="txAdvice"/></aop:config><tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes><tx:method name="save*" propagation="REQUIRED" /><tx:method name="add*" propagation="REQUIRED" /><tx:method name="update*" propagation="REQUIRED" /><tx:method name="del*" propagation="REQUIRED" /><tx:method name="cancel*" propagation="REQUIRED" /><tx:method name="*" read-only="true" /></tx:attributes></tx:advice>e)HibernateTemplate、HibernateCallback、HibernateDaoSupport（不重要）介绍i.设计模式：Template Method(模板方法)ii.Callback：回调/钩子函数iii.第一种：（建议）1.在spring中初始化HibernateTemplate，注入sessionFactory<bean id="hibernateTemplate"class="org.springframework.orm.hibernate3.HibernateTemplate"><property name="sessionFactory" ref="sessionFactory" /></bean>2.DAO里注入HibernateTemplateprivate HibernateTemplate hibernateTemplate;@Resourcepublic void setHibernateTemplate(HibernateTemplate hibernateTemplate) { this.hibernateTemplate = hibernateTemplate;}3.save写getHibernateTemplate.save();public void save(TestUser testUser) {hibernateTemplate.save(testUser);}iv.第二种：1.从HibernateDaoSupport继承(此方法不好用可忽略)2.必须写在xml文件中，无法使用Annotation，因为set方法在父类中，而且是final的例如:首先,新建SuperDAOImpl类(使用Annotation注入--@Component):@Componentpublic class SuperDAOImpl {private HibernateTemplate hibernateTemplate; //此处定义由spring注入管理public HibernateTemplate getHibernateTemplate() {return hibernateTemplate;}@Resourcepublic void setHibernateTemplate(HibernateTemplate hibernateTemplate) { this.hibernateTemplate = hibernateTemplate;}}此时,xml中必须要有:<bean id="hibernateTemplate"class="org.springframework.orm.hibernate3.HibernateTemplate"><property name="sessionFactory" ref="sessionFactory" /></bean>或者,SuperDAOImpl类写成下面代码:@Componentpublic class SuperDAOImpl extends HibernateDaoSupport {@Resource(name="sessionFactory")public void setSuperHibernateTemplate(SessionFactory sessionFactory) {super.setSessionFactory(sessionFactory);}}对应的xml中则可省略<bean id="hibernateTemplate"………部分只要包含<bean id="sessionFactory"……..部分即可最后,其他类继承SuperDaoImpl类后便可直接使用HibernateTemplate@Component("u")public class UserDAOImpl extends SuperDAOImpl implements UserDAO {public void save(TestUser testUser) {this.getHibernateTemplate().save(testUser);}}f)spring整合hibernate的时候使用packagesToScan属性，可以让spring自动扫描对应包下面的实体类Struts2.1.6 + Spring2.5.6 + Hibernate3.3.2a)将这些所有的jar包保存到一个位置，使用的时候直接copy3.步骤a)加入jar包b)首先整合Spring + Hibernatei.建立对应的package1.dao / dao.impl / model / service / service.impl/ testii.建立对应的接口与类框架1.S2SH_01iii.建立spring的配置文件（建议自己保留一份经常使用的配置文件，以后用到的时候直接copy改）iv.建立数据库v.加入Hibernate注解1.在实体类上加相应注解@Entity @Id等在字段属性的get方法上加--@Column(name = "表字段名")2.在beans配置文件配置对应的实体类，使之受管vi.写dao service的实现vii.加入Spring注解1.在对应Service及DAO实现中加入@Component，让spring对其初始化2.在Service上加入@Transactional或者使用xml方式（此处建议后者，因为更简单）3.在DAO中注入sessionFactory4.在Service中注入DAO5.写DAO与Service的实现viii.写测试c)整合Struts2i.结合点：Struts2的Action由Spring产生ii.步骤：1.修改web.xml加入struts的filter如下:<filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter </filter-class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping>2.再加入spring的listener，这样的话，webapp一旦启动，spring容器就初始化了如下:<!-- 指定由spring初始化加载xml配置文件spring与struts结合必备--><listener><listener-class>org.springframework.web.context.ContextLoaderListener<!-- 默认寻找xml路径:WEB-INF/applicationContext.xml --> </listener-class></listener><!--整个应用的参数服务启动时读取.可指定spring初始化文件路径位置--><context-param><param-name>contextConfigLocation</param-name><param-value>classpath*:spring/*applicationContext.xml</param-value></context-param>3.规划struts的action和jsp展现4.加入struts.xmla)修改配置，由spring替代struts产生Action对象5.修改action配置a)把类名改为bean对象的名称，这个时候就可以使用首字母小写了b)@Scope(―prototype‖)不要忘记iii.struts的读常量：1.struts-default.xml2.struts-plugin.xml3.struts.xml4.struts.properties5.web.xmliv.中文问题：1.Struts2.1.8已经修正，只需要改i18n.encoding = gbk2.使用spring的characterencoding例:<!-- 过滤器相关配置======== 字符编码过滤======== --><filter><filter-name>CharacterEncodingFilter</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param><init-param><param-name>forceEncoding</param-name><param-value>true</param-value></init-param></filter>3.需要严格注意filter的顺序4.需要加到Struts2的filter前面zyInitializationException1.OpenSessionInViewFilter2.需要严格顺序问题3.需要加到struts2的filter前面附:1．@Autowired 与@Resource 都可以用来装配bean. 都可以写在属性定义上,或写在set方法上@Autowired (srping提供的) 默认按类型装配@Resource ( j2ee提供的) 默认按名称装配,当找不到(不写name属性)名称匹配的bean再按类型装配. 可以通过@Resource(name="beanName") 指定被注入的bean的名称, 要是指定了name属性, 就用字段名去做name属性值,一般不用写name属性.@Resource(name="beanName")指定了name属性,按名称注入但没找到bean, 就不会再按类型装配了.@Autowired 与@Resource可作用在属性定义上, 就不用写set方法了(此方法不提倡);2．a.Action类前加@Component,则Action可由spring来管理,例子如下:Action中写:@Component("u") //spring管理注解@Scope("prototype") //多态public class UserAction extends ActionSupport implements ModelDriven{//内部属性需要有get/set方法且需要set方法前加@Resource或@Autowired }Struts2配置文件中写<action name="u" class="u">Jsp中<form method="post" action="u.do" >b.Action中也可不加@Component，Action由struts2-spring-plugin管理。

Spring学习笔记Java相关课程系列笔记之十五笔记内容说明Spring（梁建全老师主讲，占笔记内容100%）；目录一、Spring概述 (1)1.1 Spring框架的作用 (1)1.2 Spring框架的优点 (1)1.3 Spring框架的容器 (1)二、Spring容器的基本应用 (2)2.1如何将一个Bean组件交给Spring容器 (2)2.2如何获取Spring容器对象和Bean对象 (2)2.3如何控制对象创建的模式 (2)2.4 Bean对象创建的时机 (2)2.5为Bean对象执行初始化和销毁方法 (2)2.6案例：Spring框架的使用以及 2.1节-2.5节整合测试 (3)三、Spring框架IoC特性 (5)3.1 IoC概念 (5)3.2 DI概念 (5)3.3案例：测试IoC（set注入） (5)3.4案例：测试IoC（构造注入） (6)3.5案例：不用JDBC访问数据库，而是采用Hibernate访问 (6)四、Spring中各种类型的数据注入 (7)4.1 Bean对象注入 (7)4.2基本数据的注入 (7)4.3集合的注入 (7)4.4案例：各类数据注入 (7)五、AOP概念 (10)5.1什么是AOP (10)5.2 AOP和OOP的区别 (10)5.3 AOP相关术语 (10)5.4案例：AOP的使用，模拟某些组件需要记录日志的功能 (11)5.5通知类型 (11)5.6切入点 (12)5.7案例：环绕通知，修改 5.4案例使之动态显示所执行的操作 (12)5.8案例：利用AOP实现异常处理，将异常信息写入文件 (13)六、Log4j日志记录工具 (14)6.1 Log4j介绍 (14)6.2 Log4j的使用 (14)6.3案例：修改 5.8案例，使用Log4j记录日志 (15)七、Spring注解配置 (16)7.1组件扫描功能 (16)7.2组件扫描的使用方法 (16)7.3注入注解标记使用方法 (17)7.4 AOP注解标记使用方法 (17)八、Spring对数据访问技术的支持 (19)8.1 Spring提供了统一的异常处理类型 (19)8.2 Spring提供了编写DAO的支持类 (19)8.3 Spring提供了声明式事务管理方法 (19)8.4 Spring框架如何使用JDBC技术 (19)8.5连接池优点 (22)8.6 Spring框架如何使用Hibernate技术 (22)8.7 Spring+Hibernate如何使用Session、Query等对象 (25)8.8 Spring框架和Struts2整合应用 (25)8.9案例：采用SSH结构重构资费管理模块 (27)九、整合开发包 struts-spring-plugin.jar (32)9.1 Struts2创建对象的方式 (32)9.2 struts-spring-pligin.jar创建对象的方式 (32)9.3 struts-spring-plugin.jar的内部实现 (32)9.4原理图 1 (32)9.5原理图 2 (33)9.6注意事项 (33)9.7注入规则 (33)十、Spring的事务管理 (34)10.1声明式事务管理（基于配置方式实现事务控制） (34)10.2编程式事务管理（基于Java编程实现事务控制），不推荐用！ (35)10.3 Spring中常用的事务类型 (35)十一、Spring的MVC (37)11.1 Spring MVC的体系结构 (37)11.2 Spring MVC的工作流程 (37)11.3案例：简易登录（基于XML配置，不推荐使用） (37)11.4案例：修改11.3案例（基于注解配置，推荐使用） (39)十二、其他注意事项 (41)12.1 Spring的核心模块 (41)12.2表单中action属性的相对、绝对路径问题 (41)12.3用SSH重构NetCTOSS项目模块的步骤 (41)一、Spring概述我们学习Spring框架的最终目的是用它整合Struts2、Hibernate框架（SSH）。

Spring 学习笔记1.Spring的技术核心？。

Spring 是一个开源的：控制反转(Inversion of control )IOC ，依赖注入(Dependency Injection )和面向切面(Aop)的框架，它主要的目的是简化企业的开发。

2.控制反转?所谓控制反转就是：应用本身不负责依赖对象的创建与维护，依赖对象的创建与维护是有外部容器负责的。

这样控制权就有应用转向了外部容器，控制权的转移就是所谓的控制反转。

3.依赖注入?所谓依赖注入就是指：在运行期由外部容器动态的将依赖对象注入到组件中。

4 .为什么要使用Spring 呢？<a>可以降低组件之间的耦合度，实现软件各层之间的解耦；Control----→Service----→DAO<b>使用Spring 容器可以使用它提供的众多服务:事务管理服务，JMS服务，Spring Core服务，持久化服务，其它......事务管理：不需要手工控制事物<c>容器提供单利模式支持；<d>容器提供了AOP技术，利用它很容易实现如：权限拦截，运行期监控等功能。

<e>容器提供了很多的辅助类，使用这些类能够加快应用的开发，如：Jdbc Template,Hibernate Template 。

<f>Spring对主流的应用框架提供了支持如：Hibernate ,JPA , Struts.等。

4.实例化Spring 容器?两种方式A : 在类路径下寻找配置文件来实例化Spring容器。

ApplicationContext ctx = new ClassPathXmlApplicationContext(“config-path”);B:在文件系统路径下寻找配置文件来实例化Spring 容器；ApplicationContext ctx = new FileSystemXmlApplicationContext(“d:\\bean.xml”);注：第二种方式通常在本地测试时用，因为每个应用的配置在不同机器上会不同。

最全⾯的Spring学习笔记致⼒于提供⼀种⽅法管理你的业务对象。

在⼤量Java EE的应⽤中，随处可见Spring。

今天我将简单的介绍⼀下Spring这个框架。

本⽂适合读者：想学Spring的Java开发者刚⽤Spring不久的⼈Why为什么要使⽤Spring？Spring主要两个有功能为我们的业务对象管理提供了⾮常便捷的⽅法：DI（Dependency Injection，依赖注⼊）AOP（Aspect Oriented Programming，⾯向切⾯编程）Java Bean每⼀个类实现了Bean的规范才可以由Spring来接管，那么Bean的规范是什么呢？必须是个公有(public)类有⽆参构造函数⽤公共⽅法暴露内部成员属性(getter,setter)实现这样规范的类，被称为Java Bean。

即是⼀种可重⽤的组件。

DI-依赖注⼊简单来说，⼀个系统中可能会有成千上万个对象。

如果要⼿⼯维护它们之间的关系，这是不可想象的。

我们可以在Spring的XML⽂件描述它们之间的关系，由Spring⾃动来注⼊它们——⽐如A类的实例需要B类的实例作为参数set进去。

AOP-⾯向切⾯编程就以⽇志系统为例。

在执⾏某个操作前后都需要输出⽇志，如果⼿⼯加代码，那简直太可怕了。

⽽且等代码庞⼤起来，也是⾮常难维护的⼀种情况。

这⾥就需要⾯向切⾯来编程How关于BeanBean的⽣命周期如你所见，在bean准备就绪之前，bean⼯⼚执⾏了若⼲启动步骤。

我们对图进⾏详细描述：1. Spring对bean进⾏实例化；2. Spring将值和bean的引⽤注⼊到bean对应的属性中；3. 如果bean实现了BeanNameAware接⼝，Spring将bean的ID传递给setBean-Name()⽅法；4. 如果bean实现了BeanFactoryAware接⼝，Spring将调⽤setBeanFactory()⽅法，将BeanFactory容器实例传⼊；5. 如果bean实现了ApplicationContextAware接⼝，Spring将调⽤setApplicationContext()⽅法，将bean所在的应⽤上下⽂的引⽤传⼊进来；6. 如果bean实现了BeanPostProcessor接⼝，Spring将调⽤它们的post-ProcessBeforeInitialization()⽅法；7. 如果bean实现了InitializingBean接⼝，Spring将调⽤它们的after-PropertiesSet()⽅法。

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

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

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

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

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

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

【黑马程序员】Spring 全家桶Spring 概述1. 什么是spring?Spring 是个java企业级应用的开源开发框架。

Spring主要用来开发Java应用，但是有些扩展是针对构建J2EE平台的web应用。

Spring 框架目标是简化Java企业级应用开发，并通过POJO为基础的编程模型促进良好的编程习惯。

2. 使用Spring框架的好处是什么？轻量：Spring 是轻量的，基本的版本大约2MB控制反转：Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或查找依赖的对象们面向切面的编程(AOP)：Spring支持面向切面的编程，并且把应用业务逻辑和系统服务分开容器：Spring 包含并管理应用中对象的生命周期和配置MVC框架：Spring的WEB框架是个精心设计的框架，是Web框架的一个很好的替代品事务管理：Spring 提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务（JTA）异常处理：Spring 提供方便的API把具体技术相关的异常（比如由JDBC，Hibernate or JDO抛出的）转化为一致的unchecked 异常3. Spring由哪些模块组成？以下是Spring 框架的基本模块：Core moduleBean moduleContext moduleExpression Language moduleJDBC moduleORM moduleOXM moduleJava Messaging Service(JMS) moduleTransaction moduleWeb moduleWeb-Servlet moduleWeb-Struts moduleWeb-Portlet module4. 核心容器（应用上下文) 模块这是基本的Spring模块，提供spring 框架的基础功能，BeanFactory 是任何以spring 为基础的应用的核心。

Spring笔记SpringSpring是一个开源的控制反转(Inversion of Control ,IoC)和面向切面(AOP)的容器框架.它的主要目得是简化企业开发.所谓控制反转就是应用本身不负责依赖对象的创建及维护，依赖对象的创建及维护是由外部容器负责的。

这样控制权就由应用转移到了外部容器，控制权的转移就是所谓反转所谓依赖注入就是指：在运行期，由外部容器动态地将依赖对象注入到组件中。

Spring 的优点：在项目中引入spring立即可以带来下面的好处1.降低组件之间的耦合度,实现软件各层之间的解耦。

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

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

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

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

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

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

配置文件：beans.xml<="" p="" xmlns="/doc/d6*******.html,/schema/beans"> xmlns:xsi="/doc/d6*******.html,/2001/XMLSchema-instance"xsi:schemaLocation="/doc/d6*******.html ,/schema/beans/doc/d6*******.html,/schema/beans/spring-beans-2.5.xsd">。

Spring框架一、技术说明（技术介绍，技术优势以及发展史等）1.1、什么是spring●Spring是分层的JavaSE/EE full-stack 轻量级开源框架分层：三层体系结构，为每一个层都提供解决方案web层：struts2、spring-mvcservice层：springdao层：hibernate、mybatis、jdbcTemplate(spring)轻量级：使用时占用资源少，依赖程序少。

比较：EJB1.2、spring由来Expert One-to-One J2EE Design and Development ，介绍EJB，使用，特点Expert One-to-One J2EE Development without EJB ，不使用EJB，spring思想1.3、spring核心●以IoC（Inverse of Control 反转控制）和AOP（Aspect Oriented Programming 面向切面编程为内核）1.4、spring优点1.5、spring体系结构●spring 核心功能：beans、core、context、expression二、环境搭建（技术开发环境）2.1、获取Spring framework jar 包1、spring官网下载从官网下载spring 最新的相关jar包，官网download地址/springcommunity-download下载完成后会发现三个目录，命名很明确。

Docs 目录相关文档。

包括一份API 和一份各种spring 的使用说明(reference)，reference 提供了HTML.PDF 版本，非常详细。

2.spring包的核心包搭建第一个用到spring 依赖注册的程序直接用eclipse 建立一个JAVA 项目然后添加spring 的jar 包引入spring-core-3.2.0.M1.jar 核心依赖jar 包spring-context-3.2.0.M1.jar Spring 容器包spring-beans-3.2.0.M1.jar Spring beans 的管理包spring-asm-3.2.0.M1.jar Spring注：和hibernate 一起用时这个JAR 会冲突，解决方法删掉它就是了spring-expression-3.2.0.M1.jar除此之外，还有需要一个Apache common 的JAR 包注：如果忘记添加会commons-logging-1.1.1.jar 报错commons-logging-1.1.1.jar 日志记录3. 配置XMLSpring 的最大的作用就是提供bean 的管理功能，在spring 中bean 的管理是通过XML 实现的，要用此功能，需要把bean 配置到spring 的xml1. 新建立一个xml.名字任意，如applicationContext.xml,或者text.xml 都可以2. 添加xml 头定义①Xmlns(XML NameSpace) 声明命名空间，建议是用网址做命名空间，但并不会去访问改网址，仅仅是namespace 和xsd（xsd 是spring 这个xml 的schema 文件，里面定义配置内容）里声明的targetNamespace 保持一致. 注：这里命名空间是改不了的，其实是在代码中也写死了，可以打开spring-beans3.2.0.M1-sources.jar 包的org\springframework\beans\factory\xml\BeanDefinitionParserDelegate.java 查看对/schema/beans这个namespace的定义。