- 浏览: 578326 次
- 性别:
- 来自: 北京
文章分类
- 全部博客 (411)
- webservice (3)
- oracle (37)
- sqlserver (8)
- j2ee (56)
- linux (7)
- javaweb (47)
- office (1)
- struts (23)
- hibernate (11)
- spring (29)
- 网络 (2)
- tomcat (13)
- tongweb (0)
- weblogic (0)
- powerdesiginer (3)
- svn (3)
- js (20)
- ie (2)
- 编译 (3)
- css (2)
- 操作系统 (5)
- Android (41)
- jbpm4.3 (1)
- fckeditor (3)
- 操作excel (2)
- db2常用命令 (1)
- ibatis (5)
- mysql (16)
- 表达式语言 (1)
- java方式调用存储过程 (1)
- ca (1)
- linux客户端 (1)
- 电子数码 (1)
- 行业应用 (12)
- 开发工具 (4)
- 面试 (1)
- 计算机原理 (1)
- NOSQL (5)
- 虚拟机 (1)
- nginx (0)
- velocity (2)
- jndi (1)
- spring mvc (39)
- springmvc (32)
- 安全 (5)
- htmleditor (6)
- iphone4 (1)
- html (4)
- jstl (2)
- ckeditor (5)
- 连接池 (1)
- jquery (6)
- 分页 (1)
- 技术研发规则 (1)
- javamail (1)
- maven (2)
- upload (1)
- log (1)
- 测试 (10)
- spring roo (1)
- 版本控制 (2)
- find bugs (0)
- jsf (0)
- springroo (0)
- 小道理 (1)
- 小道理,技术标准 (1)
- jsf (0)
- bitbao (2)
- redmine (3)
- 团队意识 (1)
- mybatis (2)
- jquery mobile (1)
- flexpaper (0)
- json (4)
- URLRewriteFilte (1)
- html5 (1)
- 都乐保活动 (0)
- openfire (0)
- TreeMap (1)
- build (0)
- javaweb,tag (0)
- algorithm (1)
- tag (2)
- 扯淡 (0)
- mac (2)
- 叶一火(老一) (1)
- 游玩 (1)
- 编码 (1)
- 上线部署 (0)
- 研发管理 (0)
- thumbnailator (2)
- 旅游 (0)
- bingweibo (1)
- 杂谈 (4)
- ktv (1)
- weibo (1)
- 爱情 (2)
- 饮食 (1)
- MediaWiki (1)
- git (1)
- 版本库 (1)
- servlet (1)
- 感悟 (1)
- 人生 (1)
- highcharts (1)
- poi (0)
- websphere (0)
- php (1)
最新评论
-
woshixushigang:
good
org.springframework.beans.TypeMismatchException: Failed to convert property valu -
nathanleewei:
org.springframework.jdbc.core.B ...
org.springframework.beans.TypeMismatchException: Failed to convert property valu -
浪禾木:
请问是ckeditor\contents.css吗?改过以后 ...
ckeditor自动换行问题 -
simusuishi:
刚哥威武!
ckeditor取值赋值问题 -
a455642158:
收割完毕……
Android开源项目源码下载(不断更新中)
Struts,Hibernate,Spring经典面试题收藏
第一章 Spring概述
1、轻量级框架
1)框架:Hibernate、Struts、Spring
1. Struts:web层的框架
2. Hibernate:持久层的框架
3. Spring:综合框架;
2)SSH:Struts + Spring + Hibernate 三个框架的集成
2、EJB
1)使用EJB的好处:
1. 分布式处理
2. 对象的生命周期都是由EJB容器来管理的
3. 可以通过声明的方式使用容器提供的服务(比如事务服务)
Spring可以提供声明型事务,引用了EJB的事务特性。
2)EJB3.0的思想:
1. IOC:依赖注入
2. AOP:拦截器、Filter
Spring也具有这两大思想。
3、Sping的主要内容:
1)IOC(Inversion of Control,控制反转):提供依赖注入。
2)AOP(Aspect-Oriented Programming,面向方面编程):解决非业务逻辑功能的实现。
3)事务和数据访问
4)SSH
4、Sping提供了一个轻量级容器:IOC容器
1)管理javabean对象的生命周期
2)维护对象跟对象之间的依赖关系 ===> 依赖注入
重量级容器与轻量级容器的比较:
1. 重量级容器通常可以独立运行;轻量级容器通常不能独立运行,必须依赖其
他容器。
2. 重量级容器包含的服务大而全,所有应用的服务都必须购买;轻量级容器包
含的服务可以由开发人员自己选择。
3. 重量级容器直接管理线程调度;轻量级容器不关注线程调度问题。
5、为什么使用Sping?
1)提供依赖注入(通过依赖注入的方式组装对象),使得开发的系统中的组件之间的耦
合性降低(松耦合);
2)不使用J2EE中的技术,也可以通过声明的方式来获得一些服务;
3)spring是一个扩展性非常强的框架,很容易跟其他的框架进行集成,而且可以简
化被集成的框架的使用。
6、Spring的特点:
1)在spring框架中,把checked类型的异常全部转变为unchecked类型;
2)spring框架包含了很多的模块,我们可以只使用spring提供的一个或者几个模块;
3)采用spring开发的应用扩展性非常的好,而且开发出来的类都是可重用的。
7、Spring模块介绍:
1)spring Core:提供了IOC容器,是一个核心模块,是所有其他模块的基础;
2)spring AOP:提供了面向方面编程的功能;
3)spring ORM:提供了集成持久层框架的能力,用于集成其他开源的框架;
4)spring Dao:对jdbc作了一个轻量级的封装,简化了jdbc的编程;
5)spring Web:提供了集成web层框架的能力,主要用于spring跟表现层框架的集成;
6)spring Context:是spring核心模块的一个扩展模块,提供了更强大的功能;
7)spring Web MVC:spring提供的表现层框架,是一个基于mvc的web框架的实现。
第二章 Spring IOC(控制反转)
1、IOC容器:管理bean对象的生命周期,提供依赖注入并将两个对象之间的依赖关系维护
起来;依赖注入是IOC的一种表现形式。
2、好莱坞原则:
A(演员) <===== B(好莱坞)
public class A{
private B b;
/*
public A(){
b = new B();
}
*/
public void setB(B b){
this.b = b;
}
}
3、依赖注入(Dependency Injection):
1)接口注入: spring不支持
2)构造器注入: spring支持
如果在配置一个bean(bean类是标准的javabean)时,采用的注入方式是构造器
注入,那么spring容器在创建bean时调用有参的构造器,并且把它所依赖的对象注入进去。
3)setter方法注入: spring支持
如果在配置一个bean时,采用的注入方式是setter方法注入,那么spring容器
在创建bean时首先调用bean的无参构造器,然后调用bean的setter方法把它所依赖的对象
注入进来。
4、Spring中注入的数据主要有:
1)基本类型的数据:
<value>...<value/>
2)集合对象:
<list/> <set/> <map/> <props/>
3)其他的Bean:
<ref bean="..."/>
5、获得容器创建的bean对象的两种方式:
1)方式一:
// 获取xml资源文件
Resource res = new ClassPathResource("com/briup/ioc/setter/setter.xml");
// 创建IOC容器:容器的接口BeanFactory,配置文件是用xml语法写的。
BeanFactory factory = new XmlBeanFactory(res);
// 通过IOC容器获得对象:getBean传入的是bean标签中name的值
ExampleBean exampleBean = (ExampleBean)factory.getBean("exampleBean");
2)方式二:
ApplicationContext ctx = new
ClassPathXmlApplicationContext("com/briup/ioc/setter/setter.xml");
ExampleBean exampleBean = (ExampleBean)ctx.getBean("exampleBean");
6、IoC容器支持的两个不同的bean作用域:singleton和prototype
1)singleton(单例):IOC容器管理的bean默认情况下都是单例的,可以通过bean元
素中的singleton属性来控制是否为单例。
2)prototype(原型):Prototype作用域的bean会导致在每次对该bean请求(将其注入
到另一个bean中,或者以程序的方式调用容器的getBean()方法)时都会创建一个新的bean
实例。
配置:在<bean>中设置singleton="false"。
注意:根据经验,对有状态的bean应该使用prototype作用域,而对无状态的bean则
应该使用singleton作用域。
3)XmlBeanFactory默认是预先装载,在xml找到的bean对象都会__________全部装载进内存。
注意: 1.属性:pre-instantiates和lazy-init;
2.设置lazy-init="true",则表示bean对象在调用getBean时才被创
建;
3.lazy-init对BeanFactory是不起作用的;
4.XmlBeanFactory不会预先实例化单例的bean。
7、在Spring中创建非javabean类型的对象有三种方式:
1)静态工厂方法
1. 创建一个工厂类,提供一个静态的工厂方法;
2. 在配置文件中配置一个产品的bean(产品对象),class为工厂的类,另外还要
指定工厂方法的名字;
如下:
<bean id="conn" class="XXX" factory-method="getConnection"></bean>
其中getConnection是XXX中的静态方法,返回值是一个需要的对象。
2)实例工厂方法
1. 创建一个工厂类,提供一个非静态的工厂方法;
2. 配置一个工厂的bean(工厂对象);再配置一个产品的bean,并指定工厂bean
的名字,以及工厂方法的名字;
如下:
<bean id="factory" class="XXX"></bean>
<bean id="conn" factory-bean="factory" factory-method="getConnection"></bean>
其中getConnection是XXX类中的非静态方法,返回值为需要的对象,conn为
JNDI的名字。
3)提供工厂类,实现FactoryBean接口(简化我们的配置)
配置一个产品的bean,指定工厂的类。
如下:
<bean id="conn" class="com.briup.ConnectionFactory"> ... </bean>
该类必须实现FactoryBean接口和接口中的方法,返回的是connection对象.
通过factory.getBean("conn")获得的是connection对象;通过
factory.getBean("&conn")获得的是该对象本身,这里指ConnectionFactory。
8、自动装配(autowired):
1)byName:
根据当前bean所依赖的其他bean的property的名字,查找ioc容器中是否存在
名字相同的bean,如果存在则通过setter方法注入进来。
2)byType:
根据当前bean所依赖的其他bean的类型,查找ioc容器中是否存在类型相同的
bean,如果存在则通过setter方法注入进来。
3)constructor:
根据当前bean的构造器参数类型,查找ioc容器中是否存在类型相同的bean,
如果能查找到所有构造器参数,那么通过构造器注入进来。
4)autodetec:
先进行构造器装配,而后进行类型装配。
9、依赖性检查(dependency-check):
检查bean的依赖关系是否注入完毕,若没有注入完毕则报异常。
1)simple:只检测基本类型的值是否注入,而不关心对象是否注入;
2)objects:只检测对象是否注入,而不检测基本类型的值是否注入;
3)all:检测全部。
作业:
1)提供一个spring的配置文件,如user.xml。将
UserAction,UserServiceImpl,UserDaoImpl配置成spring的bean,并且维护它们之间存在的
依赖关系。
2)写一个测试类,通过spring的ioc容器获得UserAction对象,调用它的register方
法,返回success,则测试成功。
10、Spring提供的一些特殊接口:
1)BeanFactoryAware:
如果一个bean内部需要获得BeanFactory对象,那么可以让bean类实现这个接
口,BeanFactory会自动传入进来。
2)BeanNameAware:
如果一个bean内部需要获得自己的名字,那么可以让bean类实现这个接口,
bean的名字会自动传入进来。
3)FactoryBean接口:实现三个方法,简化配置。
// 工厂方法,返回产品对象
public Object getObject() throws Exception {
...
return conn;
}
// 返回产品类型
public Class getObjectType() {
return Connection.class;
}
// 返回产品是否是单例
public boolean isSingleton() {
return true;
}
main():
// 返回工厂对象
ConnectionFactory cf = (ConnectionFactory) factory.getBean("&conn");
// 返回产品对象
Connection conn = (Connection) factory.getBean("conn");
4)BeanPostProcessor:
Spring提供的一个接口,开发人员可以提供一个类实现这个接口,只要把这个
实现类配置成spring的一个bean,那么这个bean就会对其他的bean作处理。
5)BeanFactoryPostProcessor:
spring提供的一个接口,开发人员可以提供一个实现类实现这个接口,只要把
这个实现类配置成spring的一个bean,那么这个bean就会对BeanFactory作处理。
第三章 Spring AOP(面向切面编程)
1、关注点
1)核心关注点(OOP):关注系统的业务逻辑
2)横切关注点(AOP):关注系统级服务,比如事务、安全、日志
2、方面(Aspect):将散落在各处的代码规整到一处形成一个模块,这个模块称为方面。
3、连接点(Joinpoint):程序执行过程中的某一点,比如方法的调用、异常的抛出。
4、增强(Advice):为某个目标对象增加额外的功能,在spring中增强是通过拦截器实现的。
1)前增强拦截器:在目标对象方法执行之前执行的拦截器。
实现的接口:MethodBeforeAdvice
<!-- 目标对象 -->
<bean name="target" class="com.briup.aop.OrderServiceImpl"></bean>
<!-- 拦截器对象 -->
<bean name="advice" class="com.briup.aop.before.LoggerBeforeAdvice"></bean>
<!-- 创建目标对象的代理对象,注意在调用时调用的是代理对象,而不是目标对象 --
>
<bean name="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 注入目标对象 -->
<property name="target">
<ref bean="target"/>
</property>
<!-- 注入拦截器的名字,而不是拦截器对象 -->
<property name="interceptorNames">
<list>
<value>advice</value>
</list>
</property>
<!-- 注入代理对象需要实现的接口名称 -->
<property name="proxyInterfaces">
<list>
<value>com.briup.aop.IOrderService</value>
</list>
</property>
</bean>
2)后增强拦截器:在目标对象方法执行之后执行的拦截器。
实 抪_______现的接口:AfterReturningAdvice
3)环绕增强拦截器:在目标对象方法执行之前和之后都执行的拦截器。
实现的接口:MethodInterceptor
4)抛出增强拦截器:在目标对象方法执行时抛出异常才执行的拦截器。
实现的接口:ThrowsAdvice
5、切入点(Pointcut):一组连接点,如果有选择性的拦截目标对象中的方法的话需要定义切
入点。
为拦截器(advice)定义切入点从而产生增强器(advidor):
org.springframework.aop.support.RegexpMethodPointcutAdvisor
<!-- 拦截器:拦截目标对象的所有方法 -->
<bean name="advice" class="com.briup.aop.before.LoggerBeforeAdvice"></bean>
<!-- 增强器:拦截目标对象的部分方法 -->
<bean name="advisor"
class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice">
<ref bean="advice"/>
</property>
<property name="patterns">
<list>
<!-- .:通配一个字符(任意字符);*:通配前一个字符若干次 -->
<value>.*save</value>
<value>.*find</value>
</list>
</property>
</bean>
6、目标对象(Target Object):需要被增强功能的对象称之为目标对象,也被称为被增强或被
代理对象。
7、代理对象(Proxy Object):为目标对象增加额外功能之后产成的新的对象,主要负责调用
拦截器和目标对象。
1)产生代理对象的两种机制:
1.java中的动态代理:产生代理对象需要和目标对象实现共同接口;
2.第三方的cglib库:产生的代理对象是目标对象的子类对象。
2)Spring提供的专门用来产生代理对象的类:
org.springframework.aop.framework.ProxyFactoryBean
3)自动代理:不需要写配置信息就能产生代理对象
1. org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator
特点: a. 只能注入增强器,对拦截器不起作用
b. 不灵活:代理配置文件中所有的目标对象
2. org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator
特点: a. 对拦截器、增强器都起作用
b. 灵活:可选择性的代理配置文件中的目标对象
8、织入(Weaving):为目标对象增加额外功能从而产生代理对象的过程。
作业:1.给UserDao增加写日志的功能(抛出增强拦截器) -LoggerInterceptor
2.给UserService增加事务处理的功能(环绕增强拦截器实现) -TransactionInterceptor
第四章 Spring中的数据访问
1、使用JDBC
配置DataSource:
1)自己配置一个数据源:
工厂类:org.apache.commons.dbcp.BasicDataSource
产品:DataSource对象
2)查找目录服务器上的数据源:
工厂类:org.springframework.jndi.JndiObjectFactoryBean
产品:目录服务器上查找出来的数据源
2、使用hibernate
配置SessionFactory
1)创建hibernate的SessionFactory对象:
工厂类:org.springframework.orm.hibernate3.LocalSessionFactoryBean
产品:SessionFactory对象
2)目录服务器上的SessionFactory对象查找:
工厂类:org.springframework.jndi.JndiObjectFactoryBean
产品:目录服务器上查找出来的SessionFactory对象
3、事务
1)事务管理器:
1. 专门用来管理事务的一个对象,不同的持久化方式采用不同的事务管理器进
行管理。
2. 是借助于SessionFactory管理事务的。
3. Hibernate:org.springframework.orm.hibernate3.HibernateTransactionManager
2)事务拦截器:
1. 给某一个目标对象增加事务管理的功能,是借助于事务管理器管理事务的。
2. org.springframework.transaction.interceptor.TransactionInterceptor(环绕增强拦
截器)
4、Spring跟struts的集成:
1)在web.xml中配置一个监听器,用来初始化spring上下文,它会创建
ApplicationContext对象ac,并且把ac放到ServletContext中;
Spring上下文:指的是Spring IOC容器
监听器:ServletContextListener
真正类型:org.springframework.web.context.ContextLoaderListener
作用:创建spring的ioc容器,并且将其放到application范围(Servlet
Context)内。
2)在struts-config.xml文件中配置一个action,类型为spring框架提供的一个类型。
主要工作是从ServletContext中取到ApplicationContext对象ac,然后从ac中找到名字为
action path的那个bean,并且调用这个bean的execute方法;
3)在spring的配置文件中配置一个bean,类型为真正的action的类型,bean的名字
必须跟struts-config.xml中配置的action的path一致。
补充:servlet中访问spring容器中bean实例的方法
ICustomerService service = (IcustomerService)WebApplicationContextUtils
.getWebApplicationContext(request.getSession().getServletContext()).getBean("customerService");
关键字: struts, hibernate, spring
Hibernate工作原理及为什么要用?
原理:
1.读取并解析配置文件
2.读取并解析映射信息,创建SessionFactory
3.打开Sesssion
4.创建事务Transation
5.持久化操作
6.提交事务
7.关闭Session
8.关闭SesstionFactory
为什么要用:
1. 对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码。
2. Hibernate是一个基于JDBC的主流持久化框架,是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作
3. hibernate使用Java反射机制,而不是字节码增强程序来实现透明性。
4. hibernate的性能非常好,因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库,从一对一到多对多的各种复杂关系。
2. Hibernate是如何延迟加载?
1. Hibernate2延迟加载实现:a)实体对象 b)集合(Collection)
2. Hibernate3 提供了属性的延迟加载功能
当Hibernate在查询数据的时候,数据并没有存在与内存中,当程序真正对数据的操作时,对象才存在与内存中,就实现了延迟加载,他节省了服务器的内存开销,从而提高了服务器的性能。
3.Hibernate中怎样实现类之间的关系?(如:一对多、多对多的关系)
类与类之间的关系主要体现在表与表之间的关系进行操作,它们都市对对象进行操作,我们程序中把所有的表与类都映射在一起,它们通过配置文件中的many-to-one、one-to-many、many-to-many、
4. 说下Hibernate的缓存机制
1. 内部缓存存在Hibernate中又叫一级缓存,属于应用事物级缓存
2. 二级缓存:
a) 应用及缓存
b) 分布式缓存
条件:数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非 关键数据
c) 第三方缓存的实现
5. Hibernate的查询方式
Sql、Criteria,object comptosition
Hql:
1、 属性查询
2、 参数查询、命名参数查询
3、 关联查询
4、 分页查询
5、 统计函数
6. 如何优化Hibernate?
1.使用双向一对多关联,不使用单向一对多
2.灵活使用单向一对多关联
3.不用一对一,用多对一取代
4.配置对象缓存,不使用集合缓存
5.一对多集合使用Bag,多对多集合使用Set
6. 继承类使用显式多态
7. 表字段要少,表关联不要怕多,有二级缓存撑腰
7. Struts工作机制?为什么要使用Struts?
工作机制:
Struts的工作流程:
在web应用启动时就会加载初始化ActionServlet,ActionServlet从
struts-config.xml文件中读取配置信息,把它们存放到各种配置对象
当ActionServlet接收到一个客户请求时,将执行如下流程.
-(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息;
-(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;
-(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法;
-(4)如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象, 就表示表单验证成功;
-(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的 Action实例不存在,就先创建这个实例,然后调用Action的execute()方法;
-(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给 ActionForward对象指向的JSP组件;
-(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;
为什么要用:
JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。但用这些技术构建的系统非常的繁乱,所以在此之上,我们需要一个规则、一个把这些技术组织起来的规则,这就是框架,Struts便应运而生。
基于Struts开发的应用由3类组件构成:控制器组件、模型组件、视图组件
8. Struts的validate框架是如何验证的?
在struts配置文件中配置具体的错误提示,再在FormBean中的validate()方法具体调用。
9. 说下Struts的设计模式
MVC 模式: web应用程序启动时就会加载并初始化ActionServler。用户提交表单时,一个配置好的ActionForm对象被创建,并被填入表单相应的数据,ActionServler根据Struts-config.xml文件配置好的设置决定是否需要表单验证,如果需要就调用ActionForm的 Validate()验证后选择将请求发送到哪个Action,如果Action不存在,ActionServlet会先创建这个对象,然后调用 Action的execute()方法。Execute()从ActionForm对象中获取数据,完成业务逻辑,返回一个ActionForward对象,ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件,ActionForward对象指定的jsp生成动态的网页,返回给客户。
10. spring工作机制及为什么要用?
1.spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。
2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.
3.DispatcherServlet请请求提交到目标Controller
4.Controller进行业务逻辑处理后,会返回一个ModelAndView
5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象
6.视图对象负责渲染返回给客户端。
为什么用:
{AOP 让开发人员可以创建非行为性的关注点,称为横切关注点,并将它们插入到应用程序代码中。使用 AOP 后,公共服务 (比如日志、持久性、事务等)就可以分解成方面并应用到域对象上,同时不会增加域对象的对象模型的复杂性。
IOC 允许创建一个可以构造对象的应用环境,然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的,IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素(singleton)和直接构造(straight construction),每一个对象都是用其协作对象构造的。因此是由容器管理协作对象(collaborator)。
Spring即使一个AOP框架,也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring,只要用 JavaBean 属性和配置文件加入依赖性(协作对象)。然后可以很容易地在需要时替换具有类似接口的协作对象。}
Spring 框架是一个分层架构,由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上,核心容器定义了创建、配置和管理 bean 的方式,如图 1 所示。
组成 Spring 框架的每个模块(或组件)都可以单独存在,或者与其他一个或多个模块联合实现。每个模块的功能如下:
☆ 核心容器:核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory,它是工厂模式的实现。BeanFactory 使用控制反转 (IOC)模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
☆ Spring 上下文:Spring 上下文是一个配置文件,向 Spring 框架提供上下文信息。Spring 上下文包括企业服务,例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
☆ Spring AOP:通过配置管理特性,Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以,可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP,不用依赖 EJB 组件,就可以将声明性事务管理集成到应用程序中。
☆ Spring DAO:JDBC DAO 抽象层提供了有意义的异常层次结构,可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理,并且极大地降低了需要编写的异常代码数量(例如打开和关闭连接)。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
☆ Spring ORM:Spring 框架插入了若干个 ORM 框架,从而提供了 ORM 的对象关系工具,其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
☆ Spring Web 模块:Web 上下文模块建立在应用程序上下文模块之上,为基于 Web 的应用程序提供了上下文。所以,Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
☆ Spring MVC 框架:MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口,MVC 框架变成为高度可配置的,MVC 容纳了大量视图技术,其中包括 JSP、Velocity、Tiles、iText 和 POI。
Spring 框架的功能可以用在任何 J2EE 服务器中,大多数功能也适用于不受管理的环境。Spring 的核心要点是:支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象。毫无疑问,这样的对象可以在不同 J2EE 环境 (Web 或 EJB)、独立应用程序、测试环境之间重用。
IOC 和 AOP
控制反转模式(也称作依赖性介入)的基本概念是:不创建对象,但是描述创建它们的方式。在代码中不直接与对象和服务连接,但在配置文件中描述哪一个组件需要哪一项服务。容器(在 Spring 框架中是 IOC 容器) 负责将这些联系在一起。
在典型的 IOC 场景中,容器创建了所有对象,并设置必要的属性将它们连接在一起,决定什么时间调用方法。下表列出了 IOC 的一个实现模式。
Spring 框架的 IOC 容器采用类型 2 和类型3 实现。
面向方面的编程
面向方面的编程,即 AOP,是一种编程技术,它允许程序员对横切关注点或横切典型的职责分界线的行为(例如日志和事务管理)进行模块化。AOP 的核心构造是方面,它将那些影响多个类的行为封装到可重用的模块中。
AOP 和 IOC 是补充性的技术,它们都运用模块化方式解决企业应用程序开发中的复杂问题。在典型的面向对象开发方式中,可能要将日志记录语句放在所有方法和 Java 类中才能实现日志功能。在 AOP 方式中,可以反过来将日志服务模块化,并以声明的方式将它们应用到需要日志的组件上。当然,优势就是 Java 类不需要知道日志服务的存在,也不需要考虑相关的代码。所以,用 Spring AOP 编写的应用程序代码是松散耦合的。
AOP 的功能完全集成到了 Spring 事务管理、日志和其他各种特性的上下文中。
IOC 容器
Spring 设计的核心是 org.springframework.beans 包,它的设计目标是与 JavaBean 组件一起使用。这个包通常不是由用户直接使用,而是由服务器将其用作其他多数功能的底层中介。下一个最高级抽象是 BeanFactory 接口,它是工厂设计模式的实现,允许通过名称创建和检索对象。BeanFactory 也可以管理对象之间的关系。
BeanFactory 支持两个对象模型。
□ 单态 模型提供了具有特定名称的对象的共享实例,可以在查询时对其进行检索。Singleton 是默认的也是最常用的对象模型。对于无状态服务对象很理想。
□ 原型 模型确保每次检索都会创建单独的对象。在每个用户都需要自己的对象时,原型模型最适合。
bean 工厂的概念是 Spring 作为 IOC 容器的基础。IOC 将处理事情的责任从应用程序代码转移到框架。正如我将在下一个示例中演示的那样,Spring 框架使用 JavaBean 属性和配置数据来指出必须设置的依赖关系。
BeanFactory 接口
因为 org.springframework.beans.factory.BeanFactory 是一个简单接口,所以可以针对各种底层存储方法实现。最常用的 BeanFactory 定义是 XmlBeanFactory,它根据 XML 文件中的定义装入 bean,如清单 1 所示。
清单 1. XmlBeanFactory
BeanFactory factory = new XMLBeanFactory(new FileInputSteam("mybean.xml"));
在 XML 文件中定义的 Bean 是被消极加载的,这意味在需要 bean 之前,bean 本身不会被初始化。要从 BeanFactory 检索 bean,只需调用 getBean() 方法,传入将要检索的 bean 的名称即可,如清单 2 所示。
清单 2. getBean()
MyBean mybean = (MyBean) factory.getBean("mybean");
每个 bean 的定义都可以是 POJO (用类名和 JavaBean 初始化属性定义) 或 FactoryBean。FactoryBean 接口为使用 Spring 框架构建的应用程序添加了一个间接的级别。
IOC 示例
理解控制反转最简单的方式就是看它的实际应用。在对由三部分组成的 Spring 系列 的第 1 部分进行总结时,我使用了一个示例,演示了如何通过 Spring IOC 容器注入应用程序的依赖关系(而不是将它们构建进来)。
我用开启在线信用帐户的用例作为起点。对于该实现,开启信用帐户要求用户与以下服务进行交互:
☆ 信用级别评定服务,查询用户的信用历史信息。
☆ 远程信息链接服务,插入客户信息,将客户信息与信用卡和银行信息连接起来,以进行自动借记(如果需要的话)。
☆ 电子邮件服务,向用户发送有关信用卡状态的电子邮件。
三个接口
对于这个示例,我假设服务已经存在,理想的情况是用松散耦合的方式把它们集成在一起。以下清单显示了三个服务的应用程序接口。
清单 3. CreditRatingInterface
public interface CreditRatingInterface {
public boolean getUserCreditHistoryInformation(ICustomer iCustomer);
}
清单 3 所示的信用级别评定接口提供了信用历史信息。它需要一个包含客户信息的 Customer 对象。该接口的实现是由 CreditRating 类提供的。
清单 4. CreditLinkingInterface
public interface CreditLinkingInterface {
public String getUrl();
public void setUrl(String url);
public void linkCreditBankAccount() throws Exception ;
}
信用链接接口将信用历史信息与银行信息(如果需要的话)连接在一起,并插入用户的信用卡信息。信用链接接口是一个远程服务,它的查询是通过 getUrl() 方法进行的。URL 由 Spring 框架的 bean 配置机制设置,我稍后会讨论它。该接口的实现是由 CreditLinking 类提供的。
清单 5. EmailInterface
public interface EmailInterface {
public void sendEmail(ICustomer iCustomer);
public String getFromEmail();
public void setFromEmail(String fromEmail) ;
public String getPassword();
public void setPassword(String password) ;
public String getSmtpHost() ;
public void setSmtpHost(String smtpHost);
public String getUserId() ;
public void setUserId(String userId);
发表评论
-
Servlet线程安全问题
2012-10-07 11:52 1020进来休息下,来点我吧 摘 要:介绍了Servlet多线程 ... -
Collections.addAll
2012-09-07 18:04 2330collections用法以及list 简单实例 Colle ... -
string
2012-09-06 17:20 891String a = "ab"; ... -
mapper.readValue读取null
2012-08-17 19:21 2606如下代码,这样写不会走catch方法,此方法不报ioExcep ... -
string.split(",")返回的长度问题
2012-08-17 15:38 917String test = "#我的测试#&q ... -
thumbnailator 图片缩放问题
2012-08-17 19:29 2753这段代码上传1.7m图片会报错: publ ... -
模拟微博新鲜事短网址处理方式
2012-08-16 17:40 0a -
新鲜事短连接
2012-08-19 12:01 958现在需求如下: 使 ... -
jackson objectMapper.readValue 读取并存成想要的类型
2012-07-26 20:16 3716两种方式: java反射里面有个很有趣的东东,反射解析成li ... -
spring mvc responseBody 会把特殊字符转义
2012-07-26 19:53 4509框架用的spring 采用spring mvc 方式进行图片上 ... -
图片复制
2012-07-05 11:53 1068import java.io.File;import java ... -
thumbnailator 图片缩放
2012-07-04 20:10 1386Thumbnailator是一个用来生成图像缩略图的 J ... -
spring mvc 自己遇到的几个错误
2012-06-13 14:36 1202where 1=1 and t.name like '%&q ... -
Request method 'POST' not supported
2012-06-08 10:53 5208项目采用spring mvc框架实现,插入数据时候采用 ... -
org.codehaus.jackson.map.JsonMappingException
2012-08-17 19:30 989当一个类的所有属性都没有getter时(所有属性都是publi ... -
mysql 时间比较
2012-06-05 19:57 1弱智得问题,分开写 SELECT * FROM bb_ ... -
validApiToken
2012-08-10 11:26 977/** * 检验token的有效性 * @p ... -
thumbnailator 图片放缩
2012-05-21 13:44 0thumbnailator 图片放缩 Thum ... -
spring mvc title展示的几种写法
2012-05-18 17:16 1093我记录的是工作中遇到的,容易忽视的问题,高手可以绕行了。积累也 ... -
c:set 默认范围
2012-05-16 16:23 656做项目时候遇到 页面包含另一个页面,但是要通过c 标签方式 赋 ...
相关推荐
以下是对SSH面试题的详细解析,以及与SSH相关的源码和工具的知识点。 1. **SSH基本概念** - SSH的全称是Secure Shell,它为网络服务提供加密的安全通信通道。 - SSH主要用作命令行接口(CLI)远程登录,但也可...
【JAVA SSH面试题及答案】 SSH(Struts + Spring + Hibernate)是Java Web开发中常见的三大框架,它们各自承担着不同的职责,共同构建了一个高效、灵活的企业级应用程序架构。 **Hibernate工作原理及为什么使用** ...
### 面试题解析 1. **SSH框架整合开发:** - SSH框架整合开发时,Struts作为Web层的控制器,Hibernate处理数据持久化,Spring管理Struts和Hibernate的生命周期及依赖关系,实现各层之间的解耦。 2. **Struts2的...
Java-SSH面试题主要涉及到Java企业级开发中的三个重要框架:Struts、Hibernate和Spring,它们合称为SSH。这些框架的使用和集成是Java web开发中的常见知识点。 **MVC设计模式** MVC(Model-View-Controller)是一种...
SSH面试题通常指的是Java开发中三个重要框架的面试问题,这三个框架是Struts、Spring和Hibernate。在这篇文章中,我们将详细探讨关于Hibernate的部分,因为它是SSH面试中的常见考点。 **Hibernate工作原理及为什么...
通过阅读和练习《三大框架SSH面试题.docx》中的题目,你可以更好地检验自己的知识水平,找出不足并加以补充,从而提高获得高薪工作的机会。在学习过程中,不断实践和反思,将理论知识转化为实际能力,才能在面试中...
### J2EE-SSH面试题解析 #### 一、MVC设计模式理解 MVC(Model-View-Controller)设计模式是一种广泛应用于Web应用程序的设计模式,它将应用程序分为三个核心部分: 1. **模型(Model)**:模型代表了应用程序的...
有关于面试的java—SSH框架面试题目。
JAVA-SSH面试题 MVC是Model—View—Controler的简称。即模型—视图—控制器。MVC是一种设计模式,它强制性的把应用程序的输入、处理和输出分开。 MVC中的模型、视图、控制器它们分别担负着不同的任务。 视图: 视图...
【SSH面试题详解】 在Java Web开发领域,SSH(Struts、Spring、Hibernate)是一个常见的经典框架组合,常用于构建企业级应用。以下是对2013年SSH面试题的详细解析: 1. **Struts工作机制与优势** Struts是一个...
SSH面试题通常涉及对SSH协议的理解、配置、安全实践以及问题排查等多个方面。以下是一些可能的SSH面试题及相关的知识点: 1. **SSH基础概念:** - SSH如何保证通信的安全性?它采用了什么加密算法? - 什么是公钥...
### Java SSH面试题详解 #### Struts1与Struts2的工作流程及区别 **Struts1**: 在Struts1中,当一个HTTP请求到达时,`web.xml`中的配置被用于初始化`ActionServlet`,这是一个核心的Servlet,它根据`struts-...
SSH 面试题总结 本总结涵盖了 SSH 面试的常见问题,涵盖了 Hibernate、Struts 和 Spring 等技术。以下是详细的知识点: Hibernate 1. Hibernate 工作原理及为什么要用? Hibernate 通过对 JDBC 进行封装,对 ...
Java SSH面试题主要涵盖三个核心领域:Java、Spring和Hibernate,这些都是Java Web开发中的关键框架。下面将分别解析这三个框架的主要知识点。 1. **Java**: - **基础语法**:包括类、对象、接口、多态、异常处理...
最全面的ssh面试题及其知识点,其中包含struts,hibernate,spring最重要知识
Java SSH面试题主要涵盖Spring、Struts和Hibernate这三个核心Java Web开发框架的相关知识。下面将对这些框架的基本概念、功能、使用方法以及它们之间的协作进行详细介绍。 ### Spring框架 Spring是一个全面的Java...
SSH面试题通常涵盖三个主要的技术:Struts、Hibernate和Spring。以下是这些技术的相关知识点: **Hibernate** 1. **工作原理**: - Hibernate开始时,读取并解析配置文件(如hibernate.cfg.xml),获取数据库连接...