第一篇：spring总结
Spring 一：Spring流程
1.创建一个java项目
2.导入spring的支持包
3.写一个类作为被启动的类
4.书写spring的配置文件
5.启动spring容器
6.使用spring容器创建目标类对象
7.对象进行操作 二：springIOC
1.springIOC也叫作控制反转，就是让spring容器控制目标类的创建，初始化，销毁等操作。当spring是多例的时候并不能控制对象的销毁
创建bean的三种形式：
1.利用默认的构造器（必须有默认的构造函数）
2.利用静态构造方法(利用静态代码块)
3.利用实例工厂方法 只学习了两种：
创建bean的时机：
别名：alias
Spring的创建和销毁：
*初始化：
由spring容器调用init方法
在构造函数之后执行
*销毁：
单例时，由spring容器执行销毁操作，并且对象必须为ClassPathXmlApplicationContext的时候才可以，多例的情况下spring不能销毁他
三：springDI：依赖注入：给属性赋值
1.在spring中基本数据类型包括包装类和String类型
2.基本数据类型使用set方法赋值时依据的是setxxx的方法名，所以属性名和方法名要一致。
1.利用set方法给属性赋值
构造函数给属性赋值.xml
2.注解的匹配：
1、导入命名空间
xmlns:context=“http://www.xiexiebang.com.itcast.spring0909.scan”> 原理
*
* 启动spring容器，加载配置文件
*
* spring容器解析到
*
* spring容器会在指定的包及子包中查找类上是否有@Component *
* 如果@Component注解没有写任何属性
*
@Component *
public class Person{ *
*
} *
== *
如果@Component(“aa”)*
@Component *
public class Person{ *
*
} *
== *
* 在纳入spring管理的bean的范围内查找@Resource注解
*
* 执行@Resource注解的过程
* 说明：
*
xml效率比较高，但是书写比较麻烦 *
注解效率比较低，书写比较简单
继承：
四：代理
代理比较简单，所以先不写。
1.如何使用 Java 动态代理。具体有如下四步骤：
1.通过实现 InvocationHandler 接口创建自己的调用处理器；
2.通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类； 3.通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；
4.通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。
1.SpringAOP的各个概念：
1.切面：就是流程中需要执行的类
2.通知：切面中的方法
3.切入点：就是invoke方法中方法执行的条件
4.目标对象：被代理对象
5.aop对象：代理对象
6.织入：形成代理方法的过程
7.连接点：客户端调用的方法 代理对象的方法等于通知+目标方法。
1.Spring注解用的很少，了解就可以了。五：struts2深度解析：
六：spring和hibernate整合1.切入点表达式：
/表示文件夹，.表示包 七：三大框架整合 三大框架的整合步骤：
* 新建一个工程
* 把整个工程的编码改变成utf-8
* 把整个jsp页面也改变成utf-8
* 导包
web-inf
lib
struts
hibernate
spring
db
junit
* 建三个src folder
src
存放源代码的
cn.itcast.s2sh0909.struts2.action
cn.itcast.s2sh0909.dao
cn.itcast.s2sh0909.dao.impl
cn.itcast.s2sh0909.service
cn.itcast.s2sh0909.service.impl
cn.itcast.s2sh0909.domain
config
存放所有的配置文件
struts2
hibernate
spring
applicationContext.xml
applicationContext-db.xml
...........test
存放测试类
cn.itcast.s2sh0909.test
* 在dao和service层相应的包中写接口和类
* 在applicationContext-db.xml文件中写sessionFactory
* 在cn.itcast.s2sh0909.test包中新建一个类SessionFactoryTest,目的是为了测试SessionFactory
是否配置正确
* 写spring的声明式事务处理
* 在spring的配置文件中写dao和service
* 通过savePerson方法测试声明式事务处理
在Struts.xml中的action配置中，class应该写applicationContext.xml中配置Action类bean的id.
第二篇：Spring IOC原理总结
Spring IOC原理总结
Spring容器高层视图Spring 启动时读取应用程序提供的Bean配置信息，并在Spring容器中生成一份相应的Bean配置注册表，然后根据这张注册表实例化Bean，装配好Bean之间的依赖关系，为上层应用提供准备就绪的运行环境。Bean缓存池：HashMap实现IOC容器介绍Spring 通过一个配置文件描述 Bean 及 Bean 之间的依赖关系，利用 Java 语言的反射功能实例化 Bean 并建立 Bean 之间的依赖关系。Spring 的 IoC 容器在完成这些底层工作的基础上，还提供了 Bean 实例缓存、生命周期管理、Bean 实例代理、事件发布、资源装载等高级服务。BeanFactory 是 Spring 框架的基础设施，面向 Spring 本身；ApplicationContext 面向使用 Spring 框架的开发者，几乎所有的应用场合我们都直接使用 ApplicationContext 而非底层的 BeanFactory。BeanFactoryBeanFactory体系架构：BeanDefinitionRegistry： Spring 配置文件中每一个节点元素在 Spring 容器里都通过一个 BeanDefinition 对象表示，它描述了 Bean 的配置信息。而 BeanDefinitionRegistry 接口提供了向容器手工注册 BeanDefinition 对象的方法。BeanFactory 接口位于类结构树的顶端，它最主要的方法就是 getBean(String beanName)，该方法从容器中返回特定名称的 Bean，BeanFactory 的功能通过其他的接口得到不断扩展：ListableBeanFactory：该接口定义了访问容器中 Bean 基本信息的若干方法，如查看Bean 的个数、获取某一类型 Bean 的配置名、查看容器中是否包括某一 Bean 等方法；HierarchicalBeanFactory：父子级联 IoC 容器的接口，子容器可以通过接口方法访问父容器； 通过 HierarchicalBeanFactory 接口，Spring 的 IoC 容器可以建立父子层级关联的容器体系，子容器可以访问父容器中的 Bean，但父容器不能访问子容器的 Bean。Spring 使用父子容器实现了很多功能，比如在 Spring MVC 中，展现层 Bean 位于一个子容器中，而业务层和持久层的 Bean 位于父容器中。这样，展现层 Bean 就可以引用业务层和持久层的 Bean，而业务层和持久层的 Bean 则看不到展现层的 Bean。ConfigurableBeanFactory：是一个重要的接口，增强了 IoC 容器的可定制性，它定义了设置类装载器、属性编辑器、容器初始化后置处理器等方法；AutowireCapableBeanFactory：定义了将容器中的 Bean 按某种规则（如按名字匹配、按类型匹配等）进行自动装配的方法；SingletonBeanRegistry：定义了允许在运行期间向容器注册单实例 Bean 的方法；例子：使用 Spring 配置文件为 Car 提供配置信息：beans.xml：通过 BeanFactory 装载配置文件，启动 Spring IoC 容器：XmlBeanFactory 通过 Resource 装载 Spring 配置信息并启动 IoC 容器，然后就可以通过 BeanFactory#getBean(beanName)方法从 IoC 容器中获取 Bean 了。通过 BeanFactory 启动IoC 容器时，并不会初始化配置文件中定义的 Bean，初始化动作发生在第一个调用时。对于单实例（singleton）的 Bean 来说，BeanFactory会缓存 Bean 实例，所以第二次使用 getBean()获取 Bean 时将直接从 IoC 容器的缓存中获取 Bean 实例。Spring 在 DefaultSingletonBeanRegistry 类中提供了一个用于缓存单实例 Bean 的缓存器，它是一个用HashMap 实现的缓存器，单实例的 Bean 以 beanName 为键保存在这个HashMap 中。值得一提的是，在初始化 BeanFactory 时，必须为其提供一种日志框架，比如使用Log4J，即在类路径下提供 Log4J 配置文件，这样启动 Spring 容器才不会报错。ApplicationContextApplicationContext 由 BeanFactory 派生而来，提供了更多面向实际应用的功能。在BeanFactory 中，很多功能需要以编程的方式实现，而在 ApplicationContext 中则可以通过配置的方式实现。ApplicationContext 继承了 HierarchicalBeanFactory 和 ListableBeanFactory 接口，在此基础上，还通过多个其他的接口扩展了 BeanFactory 的功能：ClassPathXmlApplicationContext：默认从类路径加载配置文件FileSystemXmlApplicationContext：默认从文件系统中装载配置文件ApplicationEventPublisher：让容器拥有发布应用上下文事件的功能，包括容器启动事件、关闭事件等。实现了 ApplicationListener 事件监听接口的 Bean 可以接收到容器事件，并对事件进行响应处理。在 ApplicationContext 抽象实现类AbstractApplicationContext 中，我们可以发现存在一个 ApplicationEventMulticaster，它负责保存所有监听器，以便在容器产生上下文事件时通知这些事件监听者。MessageSource：为应用提供 i18n 国际化消息访问的功能；ResourcePatternResolver ： 所 有 ApplicationContext 实现类都实现了类似于PathMatchingResourcePatternResolver 的功能，可以通过带前缀的 Ant 风格的资源文件路径装载 Spring 的配置文件。LifeCycle：该接口是 Spring 2.0 加入的，该接口提供了 start()和 stop()两个方法，主要用于控制异步处理过程。在具体使用时，该接口同时被 ApplicationContext 实现及具体 Bean 实现，ApplicationContext 会将 start/stop 的信息传递给容器中所有实现了该接口的 Bean，以达到管理和控制 JMX、任务调度等目的。ConfigurableApplicationContext 扩展于
ApplicationContext，它新增加了两个主要的方法： refresh()和 close()，让 ApplicationContext 具有启动、刷新和关闭应用上下文的能力。在应用上下文关闭的情况下调用 refresh()即可启动应用上下文，在已经启动的状态下，调用 refresh()则清除缓存并重新装载配置信息，而调用close()则可关闭应用上下文。这些接口方法为容器的控制管理带来了便利，但作为开发者，我们并不需要过多关心这些方法。使用：如果配置文件放置在类路径下，用户可以优先使用 ClassPathXmlApplicationContext 实现类：如果配置文件放置在文件系统的路径下，则可以优先考虑使用
FileSystemXmlApplicationContext 实现类：Spring 3.0 支持基于类注解的配置方式，主要功能来自于 Spring 的一个名为 JavaConfig 子项目，目前 JavaConfig已经升级为 Spring核心框架的一部分。ApplicationContext 在初始化应用上下文时就实例化所有单实例的 Bean。WebApplicationContextWebApplication体系架构：WebApplicationContext 是专门为 Web 应用准备的，它允许从相对于 Web 根目录的路径中装载配置文件完成初始化工作。从WebApplicationContext 中可以获得
ServletContext 的引用，整个 Web 应用上下文对象将作为属性放置到 ServletContext 中，以便 Web 应用环境可以访问 Spring 应用上下文。WebApplicationContext 定义了一个常量ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE，在上下文启动时，WebApplicationContext 实例即以此为键放置在 ServletContext 的属性列表中，因此我们可以直接通过以下语句从 Web 容器中获取WebApplicationContext：Spring 和 Web 应用的上下文融合：WebApplicationContext 的初始化方式：WebApplicationContext 需要 ServletContext 实例，它必须在拥有 Web 容器的前提下才能完成启动的工作。可以在 web.xml 中配置自启动的 Servlet 或定义 Web 容器监听器（ServletContextListener），借助这两者中的任何一个就可以完成启动 Spring Web 应用上下文的工作。Spring 分别提供了用于启动 WebApplicationContext 的 Servlet 和 Web 容器监听器：org.springframework.web.context.ContextLoaderServlet；org.springframework.web.context.ContextLoaderListener由于 WebApplicationContext 需要使用日志功能，比如日志框架使用Log4J，用户可以将 Log4J 的配置文件放置到类路径 WEB-INF/classes 下，这时 Log4J 引擎即可顺利启动。如果 Log4J 配置文件放置在其他位置，用户还必须在 web.xml 指定 Log4J 配置文件位置。Bean的生命周期1．当调用者通过 getBean(beanName)向容器请求某一个 Bean 时，如果容器注册了org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor 接口，在实例化 Bean 之前，将调用接口的 postProcessBeforeInstantiation()方法；2．根据配置情况调用 Bean 构造函数或工厂方法实例化 Bean；3．如果容器注册了 InstantiationAwareBeanPostProcessor 接口，在实例化 Bean 之后，调用该接口的
postProcessAfterInstantiation()方法，可在这里对已经实例化的对象进行一些“梳妆打扮”；4．如果 Bean 配置了属性信息，容器在这一步着手将配置值设置到 Bean 对应的属性中，不过在设置每个属性之前将先调用InstantiationAwareBeanPostProcessor 接口的postProcessPropertyValues()方法；5．调用 Bean 的属性设置方法设置属性值；6．如果 Bean 实现了
org.springframework.beans.factory.BeanNameAware 接口，将调用setBeanName()接口方法，将配置文件中该 Bean 对应的名称设置到 Bean 中；7．如果 Bean 实现了 org.springframework.beans.factory.BeanFactoryAware 接口，将调用 setBeanFactory()接口方法，将 BeanFactory 容器实例设置到 Bean 中；8．如果 BeanFactory 装配了 org.springframework.beans.factory.config.BeanPostProcessor后处理器，将调用 BeanPostProcessor 的 Object postProcessBeforeInitialization(Object bean, String beanName)接口方法对 Bean 进行加工操作。其中入参 bean 是当前正在处理的 Bean，而 beanName 是当前 Bean 的配置名，返回的对象为加工处理后的 Bean。用户可以使用该方法对某些 Bean 进行特殊的处理，甚至改变 Bean 的行为，BeanPostProcessor 在 Spring 框架中占有重要的地位，为容器提供对 Bean 进行后续加工处理的切入点，Spring 容器所提供的各种“神奇功能”（如 AOP，动态代理等）都通过 BeanPostProcessor 实施；9．如果 Bean 实现了 InitializingBean 的接口，将调用接口的
afterPropertiesSet()方法；10．如果在通过 init-method 属性定义了初始化方法，将执行这个方法；11．BeanPostProcessor 后处理器定义了两个方法：其一是 postProcessBeforeInitialization()在第 8 步调用；其二是 Object postProcessAfterInitialization(Object bean, String beanName)方法，这个方法在此时调用，容器再次获得对 Bean 进行加工处理的机会；12．如果在中指定 Bean 的作用范围为 scope=“prototype”，将 Bean 返回给调用者，调用者负责 Bean 后续生命的管理，Spring 不再管理这个 Bean 的生命周期。如果作用范围设置为 scope=“singleton”，则将 Bean 放入到 Spring IoC 容器的缓存池中，并将 Bean引用返回给调用者，Spring 继续对这些 Bean 进行后续的生命管理；13．对于 scope=“singleton”的 Bean，当容器关闭时，将触发 Spring 对 Bean 的后续生命周期的管理工作，首先如果 Bean 实现了 DisposableBean 接口，则将调用接口的afterPropertiesSet()方法，可以在此编写释放资源、记录日志等操作；14．对于 scope=“singleton”的 Bean，如果通过的 destroy-method 属性指定了 Bean 的销毁方法，Spring 将执行 Bean 的这个方法，完成 Bean 资源的释放等操作。可以将这些方法大致划分为三类：Bean 自身的方法：如调用 Bean 构造函数实例化 Bean，调用 Setter 设置 Bean 的属性值以及通过的 init-method 和 destroy-method 所指定的方法；Bean 级生命周期接口方法：如 BeanNameAware、BeanFactoryAware、InitializingBean 和 DisposableBean，这些接口方法由 Bean 类直接实现；容器级生命周期接口方法：在上图中带“★” 的步骤是由 InstantiationAwareBean PostProcessor 和BeanPostProcessor 这两个接口实现，一般称它们的实现类为“ 后处理器”。后处理器接口一般不由 Bean 本身实现，它们独立于 Bean，实现类以容器附加装置的形式注册到 Spring 容器中并通过接口反射为 Spring 容器预先识别。当Spring 容器创建任何 Bean 的时候，这些后处理器都会发生作用，所以这些后处理器的影响是全局性的。当然，用户可以通过合理地编写后处理器，让其仅对感兴趣Bean 进行加工处理ApplicationContext 和 BeanFactory 另一个最大的不同之处在于：ApplicationContext会利用 Java 反射机制自动识别出配置文件中定义的 BeanPostProcessor、InstantiationAwareBeanPostProcessor 和
BeanFactoryPostProcessor，并自动将它们注册到应用上下文中；而后者需要在代码中通过手工调用
addBeanPostProcessor()方法进行注册。这也是为什么在应用开发时，我们普遍使用 ApplicationContext 而很少使用 BeanFactory 的原因之一IOC容器工作机制容器启动过程web环境下Spring容器、SpringMVC容器启动过程：首先，对于一个web应用，其部署在web容器中，web容器提供其一个全局的上下文环境，这个上下文就是ServletContext，其为后面的spring IoC容器提供宿主环境；其次，在web.xml中会提供有contextLoaderListener（或ContextLoaderServlet）。在web容器启动时，会触发容器初始化事件，此时contextLoaderListener会监听到这个事件，其contextInitialized方法会被调用，在这个方法中，spring会初始化一个启动上下文，这个上下文被称为根上下文，即WebApplicationContext，这是一个接口类，确切的说，其实际的实现类是XmlWebApplicationContext。这个就是spring的IoC容器，其对应的Bean定义的配置由web.xml中的context-param标签指定。在这个IoC容器初始化完毕后，spring容器以WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE为属性Key，将其存储到ServletContext中，便于获取；再次，contextLoaderListener监听器初始化完毕后，开始初始化web.xml中配置的Servlet，这个servlet可以配置多个，以最常见的DispatcherServlet为例（Spring MVC），这个servlet实际上是一个标准的前端控制器，用以转发、匹配、处理每个servlet请求。DispatcherServlet上下文在初始化的时候会建立自己的IoC上下文容器，用以持有spring mvc相关的bean，这个servlet自己持有的上下文默认实现类也是XmlWebApplicationContext。在建立DispatcherServlet自己的IoC上下文时，会利用WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE先从ServletContext中获取之前的根上下文(即WebApplicationContext)作为自己上下文的parent上下文（即第2步中初始化的XmlWebApplicationContext作为自己的父容器）。有了这个parent上下文之后，再初始化自己持有的上下文（这个DispatcherServlet初始化自己上下文的工作在其initStrategies方法中可以看到，大概的工作就是初始化处理器映射、视图解析等）。初始化完毕后，spring以与servlet的名字相关(此处不是简单的以servlet名为Key，而是通过一些转换)的属性为属性Key，也将其存到ServletContext中，以便后续使用。这样每个servlet就持有自己的上下文，即拥有自己独立的bean空间，同时各个servlet共享相同的bean，即根上下文定义的那些bean。Bean加载过程Spring的高明之处在于，它使用众多接口描绘出了所有装置的蓝图，构建好Spring的骨架，继而通过继承体系层层推演，不断丰富，最终让Spring成为有血有肉的完整的框架。所以查看Spring框架的源码时，有两条清晰可见的脉络：1）接口层描述了容器的重要组件及组件间的协作关系；2）继承体系逐步实现组件的各项功能。接口层清晰地勾勒出Spring框架的高层功能，框架脉络呼之欲出。有了接口层抽象的描述后，不但Spring自己可以提供具体的实现，任何第三方组织也可以提供不同实现，可以说Spring完善的接口层使框架的扩展性得到了很好的保证。纵向继承体系的逐步扩展，分步骤地实现框架的功能，这种实现方案保证了框架功能不会堆积在某些类的身上，造成过重的代码逻辑负载，框架的复杂度被完美地分解开了。Spring组件按其所承担的角色可以划分为两类：1）物料组件：Resource、BeanDefinition、PropertyEditor以及最终的Bean等，它们是加工流程中被加工、被消费的组件，就像流水线上被加工的物料；BeanDefinition：Spring通过BeanDefinition将配置文件中的配置信息转换为容器的内部表示，并将这些BeanDefinition注册到BeanDefinitionRegistry中。Spring容器的后续操作直接从BeanDefinitionRegistry中读取配置信息。2）加工设备组件：ResourceLoader、BeanDefinitionReader、BeanFactoryPostProcessor、InstantiationStrategy以及BeanWrapper等组件像是流水线上不同环节的加工设备，对物料组件进行加工处理。InstantiationStrategy：负责实例化Bean操作，相当于Java语言中new的功能，并不会参与Bean属性的配置工作。属性填充工作留待BeanWrapper完成BeanWrapper：继承了PropertyAccessor和PropertyEditorRegistry接口，BeanWrapperImpl内部封装了两类组件：（1）被封装的目标Bean（2）一套用于设置Bean属性的属性编辑器；具有三重身份：（1）Bean包裹器（2）属性访问器（3）属性编辑器注册表。PropertyAccessor：定义了各种访问Bean属性的方法。PropertyEditorRegistry：属性编辑器的注册表该图描述了Spring容器从加载配置文件到创建出一个完整Bean的作业流程：１、ResourceLoader从存储介质中加载Spring配置信息，并使用Resource表示这个配置文件的资源；２、BeanDefinitionReader读取Resource所指向的配置文件资源，然后解析配置文件。配置文件中每一个解析成一个BeanDefinition对象，并保存到BeanDefinitionRegistry中；３、容器扫描BeanDefinitionRegistry中的BeanDefinition，使用Java的反射机制自动识别出Bean工厂后处理后器（实现BeanFactoryPostProcessor接口）的Bean，然后调用这些Bean工厂后处理器对BeanDefinitionRegistry中的BeanDefinition进行加工处理。主要完成以下两项工作：1）对使用到占位符的元素标签进行解析，得到最终的配置值，这意味对一些半成品式的BeanDefinition对象进行加工处理并得到成品的BeanDefinition对象；2）对BeanDefinitionRegistry中的BeanDefinition进行扫描，通过Java反射机制找出所有属性编辑器的Bean（实现java.beans.PropertyEditor接口的Bean），并自动将它们注册到Spring容器的属性编辑器注册表中（PropertyEditorRegistry）；4．Spring容器从BeanDefinitionRegistry中取出加工后的BeanDefinition，并调用InstantiationStrategy着手进行Bean实例化的工作；5．在实例化Bean时，Spring容器使用BeanWrapper对Bean进行封装，BeanWrapper提供了很多以Java反射机制操作Bean的方法，它将结合该Bean的BeanDefinition以及容器中属性编辑器，完成Bean属性的设置工作；6．利用容器中注册的Bean后处理器（实现BeanPostProcessor接口的Bean）对已经完成属性设置工作的Bean进行后续加工，直接装配出一个准备就绪的Bean。总结Spring IOC容器主要有继承体系底层的BeanFactory、高层的ApplicationContext和WebApplicationContextBean有自己的生命周期容器启动原理：Spring应用的IOC容器通过tomcat的Servlet或Listener监听启动加载；Spring MVC的容器由DispatchServlet作为入口加载；Spring容器是Spring MVC容器的父容器容器加载Bean原理：BeanDefinitionReader读取Resource所指向的配置文件资源，然后解析配置文件。配置文件中每一个解析成一个BeanDefinition对象，并保存到BeanDefinitionRegistry中；容器扫描BeanDefinitionRegistry中的BeanDefinition；调用InstantiationStrategy进行Bean实例化的工作；使用BeanWrapper完成Bean属性的设置工作；单例Bean缓存池：Spring 在 DefaultSingletonBeanRegistry 类中提供了一个用于缓存单实例 Bean 的缓存器，它是一个用 HashMap 实现的缓存器，单实例的 Bean 以 beanName 为键保存在这个HashMap 中。
1、具有1-5工作经验的，面对目前流行的技术不知从何下手，需要突破技术瓶颈的可以加群。
2、在公司待久了，过得很安逸，但跳槽时面试碰壁。需要在短时间内进修、跳槽拿高薪的可以加群。
3、如果没有工作经验，但基础非常扎实，对java工作机制，常用设计思想，常用java开发框架掌握熟练的，可以加群。
4、觉得自己很牛B，一般需求都能搞定。但是所学的知识点没有系统化，很难在技术领域继续突破的可以加群。5.Java架构进阶群号：668395460
第三篇：Spring MVC使用总结
Org.springframework.ui.ModelMap传递数据供视图所用
${base}取的是当前页面所在的路径。它随页面的位置改变而改变。
web开发一共有四个作用域，范围从高到低分为appliaction作用域（全局作用域），session作用域,request作用域和page作用域。
${base}是el表达式语法，它会自动先从page作用域开始查找，如果没有再找request作用域，然后是session，最后再是application作用域。
动态网页项目，页面直接访问的是webcontent下的。
Weblogic.xml配置文件作用： weblogic.xml主要配置web容器的一些属性，比较JSP编译时间间隔、编译路径等 web.xml是配置整个应用工程的属性，如servlet等
你用tomcatjboss等web容器和weblogic一样，它们单独有自己的配置文件
视图解析器
SpringMVC用于处理视图最重要的两个接口是ViewResolver和View
FreeMarkerViewResolver是继承自springmvc的一个接口，只是和freemarker同名而已
XmlViewResolver
貌似工具库里面定义好了（如ftl、分词库），然后在common中用
<@s.m “error.errorMessage”/>什么意思？？
视频
spring mvc
freemarker
金磊
今天问题
VECTOR-
脚本语言-
注解--
为什么frame要经过FrameAct.java一下，再返回？？
@Controller是spring的Controller控制器？
为什么我新建的html是
别人是
jar包
apache下的jar包
apache-ant-zip-1.8.0.jar（ant是什么？？它的jar包？？ant是脚本引擎，脚本语言有
JavaScript）
c3p0-0.9.1.2.jar
commons-codec-1.3.jar
commons-net-2.0.jar
commons-net-ftp-2.0.jar
dwr.jar
ehcache-1.6.2.jar
ganymed-ssh2-build251beta1.jar
htmlparser-1.6.jar
httpclient-4.0.3.jar
httpcore-4.1.jar
IKAnalyzer2012_u6.jar
jcaptcha-1.0.jar
jcl-over-slf4j-1.6.1.jar
jmagick.jar
json.jar
jta-1.1.jar
jug-2.0.0.jar
log4j-over-slf4j-1.6.1.jar
logback-classic-0.9.27.jar
logback-core-0.9.27.jar
lucene-core-3.0.3.jar
mailapi-1.4.2.jar
memcachedclient-2.0.1.jar
mysql-connector-5.1.8.jar
quartz-1.6.0.jar
slf4j-api-1.6.1.jar
smtp-1.4.2.jar
spymemcached-2.3.1.jar
----
spring mvc环境搭建：
1、web.xml，启动Dispatcher2、创建servlet3、创建controller.java（在spring mvc中，只要加了@controller就说明它是一个controller控制器了，非常简单）
其它注解
@RequestMapping(“/frame/config_main.do”)只要页面上访问这个路径，就会返回这
个注解下的方法的return的方法。
学习任何MVC都要掌握的步骤：
1、搭建环境（写hello world）
2、传值
3、截获值
4、分发值
5、源码
6、异常
7、上传下载
第四篇：Spring 事物机制总结
spring两种事物处理机制，一是声明式事物，二是编程式事物 声明式事物
1）Spring的声明式事务管理在底层是建立在AOP的基础之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明（或通过等价的基于标注的方式），便可以将事务规则应用到业务逻辑中。因为事务管理本身就是一个典型的横切逻辑，正是AOP的用武之地。Spring开发团队也意识到了这一点，为声明式事务提供了简单而强大的支持。Spring强大的声明式事务管理功能，这主要得益于Spring依赖注入容器和Spring AOP的支持。依赖注入容器为声明式事务管理提供了基础设施，使得Bean对于Spring框架而言是可管理的；而Spring AOP则是声明式事务管理的直接实现者。和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求，也存在很多变通的方法，比如，可以将需要进行事务管理的代码块独立为方法等等。2）5种配置方式
Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。
DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用hibernate进行数据访问时，DataSource实际为SessionFactory，TransactionManager的实现为HibernateTransactionManager。关系图如下：
[html] view plain copy
1.
3．4.5.
6.7.
8.
9.10.
注意：sessionFactorty和transactionManager是下面5中配置方式的基本配置，第一种方式：每个Bean都有一个代理
[html] view plain copy
1.
2.
3.4.
5.6.
7.
8．9.
10.11.
12．13.
14.PROPAGATION_REQUIRED
15.
16.
17.
第二种方式：所有Bean共享一个代理基类
[html] view plain copy
1.
2.
3.4.
5.6.
7.PROPAGATION_REQUIRED
8. 9.
10.
11.12.
13.
14.15.
16.17.
18.19.
第三种方式：使用拦截器
[html] view plain copy
1.
2.3.
4．5.
6.PROPAGATION_REQUIRED
7.
8.
9.
10.11.
12.13.
14.
15.
16.
17.18.
19.
20.
21.
22.
23.24.
25.
26.27.
第四种方式：使用tx标签配置的拦截器
[html] view plain copy
1.
3.
5.
6.7.
8. 9.expression=“execution(* com.test.spring.dao.*.*(..))” /> 10. 11. 第五种方式：全注解 [java] view plain copy 1.public class test { 2.@Transactional 3.public class UserDaoImpl extends HibernateDaoSupport implements UserDao { 4.5.public List 7.} 8.} 9.} 编程式事务 Spring的编程式事务即在代码中使用编程的方式进行事务处理，可以做到比声明式事务更细粒度。有两种方式一是使用TransactionManager，另外就是TransactionTemplate。1）TransactionManager使用方式 [java] view plain copy 1.public class UserDaoImpl extends HibernateDaoSupport implements UserDao { 2.private HibernateTransactionManager transactionManager;3.private DefaultTransactionDefinition def;4.5.public HibernateTransactionManager getTransactionManager(){ 6.return transactionManager;7.} 8.9.public void setTransactionManager(HibernateTransactionManager transactionManager){ 10.this.transactionManager = transactionManager;11.} 12.13.public void createTransactionDefinition(){ 14.def = new DefaultTransactionDefinition(); 15.def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);16.def.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);17.} 18.19.public void saveOrUpdate(User user){ 20.TransactionStatus status = transactionManager.getTransaction(def);21.try { 22.this.getHibernateTemplate().saveOrUpdate(user);23.} catch(DataAccessException ex){ 24.transactionManager.rollback(status);25.throw ex; 26.} 27.transactionManager.commit(status);28.} 29.} 2）TransactionTemplate方式 [java] view plain copy 1.ResultDto ret = null; 2.ret =(ResultDto)this.transactionTemplate.execute(new TransactionCallback(){ 3.@Override 4.public Object doInTransaction(TransactionStatus status){ 5.ResultDto ret = null; 6.try { 7.drillTaskDao.deleteByKey(taskid); 8.} catch(Exception e){ 9.logger.error(“delDrillTask:” + e.getMessage(), e); 10.ret = ResultBuilder.buildResult(ResultBuilder.FAIL_CODE, null, ErrorCode.COM_DBDELETEERROR);11.return ret;12.} 13.finally { 14.status.setRollbackOnly();15.} 16.17.ret = cleartaskrelativedata(taskid, appid, true);18.return ret;19.} 20.}); 21.return ret; Spring教学大纲 1.Spring简介:一站式框架 Spring能为我们带来什么？ a)使层与层之间只依赖于接口 b)Spring的bean工厂为我们创建对象，不需要程序员自己new对象了(IOC:inverse of control控制反转，DI:depandency injection 依赖注入)c)可以管理事务 d)可以对其他框架进行管理(struts2,hibernate)e)也可以使用spring自带的springMVC框架 f)也可以使用spring的JDBC模板 2.Spring IOC(DI)常用的注入方式： 1.构造器注入 2.setter注入(set方法注入)(常用)注意：setter方法注入，必须提供无参构造方法 3.Spring Bean的范围 常用的范围： Singleton：单例模式，建议不要存在具有状态的成员变量,该项为默认项 Prototype:只要使用该对象，那就创建一个新的 注意：spring在与struts2整合时，需要将产生action的bean，配置为scope=”prototype” 4.Spring自动装配 a)byName 要求：bean id必须与包含此类成员的类的成员变量名相同 b)byType 根据类型查找，将查找到的对象注入到成员变量中 5.使用spring自带的JDBC模板 6.事务管理 7.Spring管理hibernate 8.spring整合struts2 步骤： 1.在项目中要引入struts2-spring-plugin-x-x-x.jar文件，该文件的位置：struts2的lib目录下 2.在struts.xml中配置： contextConfigLocation classpath*:applicationContext-beans.xml 注意：在spring中生成action对象时，最好配置scope=”prototype” 9.Ssh整合开发第五篇：spring教学大纲
点击咨询 