Java程序员Spring相关的面试要点整理

spring是一个轻量级的容器,非侵入性的框架.最重要的核心概念是IOC,
并提供AOP概念的实现方式,提供对持久层,事务的支持,
对当前流行的一些框架(Struts,Hibernate,MVC),Sping也提供了与它们的相整合的方案.
使用Spring,我们能够减少类之间的依赖性和程序之间的耦合度,
最大程度的实现松耦合,使程序更加灵活,可扩展性更强.
IOC,中文翻译为"反转控制,".DI->"依赖注入"
指的是：我们不必自己在程序代码中维护对象的依赖关系,
而是通过一个xml配置文件,将类的属性和实例悄悄的注入到类里面.
实现类的动态加载,使得类和类之间可以方便的切换(通过接口).
这种设计方式的思想表现为:
高层模块不应该依赖低层模块,而是模块都必须依赖于抽象.
程序不应改依赖于实现,而是依赖于抽象接口.
应用程序不要去找容器,而是容器给我们所有想要的对象.

ApplicationContext  FileSystemXmlApplicationContext
Resource   FileSystemResource   BeanFactory   XmlBeanFactory

Spring的另一个重要的方面是支持AOP的实现:
AOP的中文翻译是:面向切面编程,也称为面向问题编程.
我举一个例子........
通过这种设计方式,可以对类进行监控,实现类的动态代理.

java.lang.reflect.InvocationHandler
invoke(Object Method,Object[])

包:core,aop,context,mvc,dao,beans,web,orm

spirng获得数据源:org.springframework.jdbc.datasource.DriverManagerDataSource
spring访问数据:org.springframework.jdbc.core.JdbcTemplate
spring事务处理:org.springframework.jdbc.datasource.DataSourceTransactionManager

spring声明事务处理:org.springframework.transaction.interceptor.TransactionProxyFactoryBean
<property name="transactionAttributes">
<props>
<prop key="create">PROPAGATION_REQUIRED</prop>如果没有事务就新建一个事务
</props>

sping和struts 整合:
1.注册声明使用spring代理
struts-config.xml
<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation"
value="/WEB-INF/classes/applicationContext.xml/>
</plug-in>
2. action path="/GroupAction" name="imForm" type="org.springframework.web.struts.DelegatingActionProxy" 将type改成spring的代理类
3.在applications.xml 注意：name必须和要代理的path一致
<bean name="/GroupAction" class="com.cotel.web.struts.action.security.GroupAction" singleton="false">
<property name="groupBean">
<ref bean="groupBean"/>
</property>
</bean>
4.在action里面
GroupBeanImpl groupBean
public GroupBeanImpl getGroupBean(){
return groupBean;
}
public void setGroupBean(GroupBeanImpl groupBean){
this.groupBean = GroupBeanImpl groupBean;
}
用的时候:getGroupBean()就可以获得实例了.

抽象:
忽略掉一个对象或实体的细节而只关注其本质特征的过程.
封装:
隐藏一个类的数据与实现过程,而只是提供统一的功能调用格式的做法.封装使得类与模块的开发者与使用者在角色上分离开来.
继承:
通过存在的类型定义新类型的机制.提高代码重用.

11.接口的好处?
a.实现多继承.
b.类和类之间可以动态的切换.
c.通过将接口暴露给调用者，能够将接口的实现屏蔽掉.更好的实现封装.
spring:
core,aop,context,mvc,dao,beans,web
IOC:控制反转,依赖注入
AOP:面向切面编程,面向问题编程

针对接口进行编程：
返回值尽量抽象,参数尽量抽象,避免了跟底层的接触,减少程序间的耦合度和类之间的依赖性,使程序更加灵活,可扩展性更强.

依赖注入的目标是为了提升组件重用的概率,并为系统搭建一个灵活,可扩展的平台.

5.AOP是什么?
IOC的扩展.对类进行监控,实现类的动态加载.

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.InputStreamResource;

//BeanFactory是spring里已经写好的代理类,已经注入依赖
private BeanFactory factory = null;

//通过BeanFactory的getBean方法获得实例
//@ id:对应beanFactory.xml里<bean id="">属性
public Object getBean(String id) {
return factory.getBean(id);
}

//利用spring去解析传进来的xml文件
//@ xmlPath:xml文件名
public void init(String xmlPath) throws Exception {
InputStream is = new FileInputStream(xmlPath);
InputStreamResource isr = new InputStreamResource(is);
factory = new XmlBeanFactory(isr);
}

<?xml version="1.0" encoding="GBK"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<!--把encoding=UTF-8改成CBK就可以写中文了-->
<!--id=标示符,class="lianxi.Simple"对应class路径-->
<bean id="simple" class="lianxi.Simple">
<!--name="say"对应方法名-->
<property name="say">
<value>Hello World!</value>
</property>
</bean>

<bean id="demo" class="lianxi.Demo">
<!--name="tall"对应方法名-->
<property name="tall">
<value>happay new year !</value>
</property>
</bean>

<bean id="db" class="lianxi.DB">
<!--name="properties": 指setProperties方法.-->
<!--<props>里的内容就是setProperties方法参数的值-->
<property name="properties">
<props>
<prop key="driver">oracle.jdbc.OracleDriver</prop>
<prop key="url">oracle:jdbc:thin:@192.168.2.100</prop>
<prop key="username">tarena</prop>
<prop key="password">tarena</prop>
</props>
</property>
</bean>

<bean id="single" class="lianxi.Single" singleton="false">
<property name="data">
<value>happay Spring !</value>
</property>
</bean>

<!--当<bean>里有factory-method属性的时候spring就会去调用属性里的指的方法获得实例,用于单例模式-->
<!--<constructor-arg>里的内容就是构造方法里的参数-->
<bean id="paramSingle" class="lianxi.ParamSingle" factory-method="getInstance">
<constructor-arg>
<value>Hello World !</value>
</constructor-arg>
<!--<ref bean="db"></ref>引用的类一定要在这个xml里存在-->
<constructor-arg>
<ref bean="db"></ref>
</constructor-arg>
<constructor-arg>
<!--集合的值可以有多个-->
<set>
<value>Hello IOC !</value>
<value>Hello spring !</value>
</set>
</constructor-arg>
</bean>

<bean id="tc" class="lianxi.TestConstructor">
<constructor-arg>
<ref bean="single"></ref>
</constructor-arg>
<constructor-arg>
<value>100</value>
</constructor-arg>
</bean>

<bean id="testList" class="lianxi.TestList">
<constructor-arg>
<list>
<ref bean="db"></ref>
</lis
</constructor-arg>
</bean>

<bean id="testMap" class="lianxi.TestMap">
<constructor-arg>
<map>
<entry key="yup an entry">
<value>just some string</value>
</entry>
<entry key="db">
<ref bean="db"></ref>
</entry>
</map>
</constructor-arg>
</bean>

</beans>

Hibernate是一个轻量级的持久层开源框架,
它是连接Java应用程序和关系数据库的中间件,负责Java对象和关系数据之间的映射.
Hibernate内部对JDBC API进行了封装,负责Java对象的持久化.
因为它封装了所有的数据访问细节,使得业务逻辑层可以专注于实现业务逻辑.
它是一种优秀的ORM映射工具,提供了完善的对象－关系映射服务,开发过程不依赖容器,灵活性非常大,可以无缝集成到任何一个java系统中.

请谈谈JDBC,Hibernate,EJB三者的区别?

这三者都是用做数据持久化操作的.

JDBC:
实现业务逻辑的代码和访问数据库的代码混杂在一起,使程序结构不清晰,可读性差.

java是面向对象的,sql是面向关系的.两者混在一起,我们不能完全的运用面向对象的思维来编写程序.

业务逻辑和关系数据模型绑定,如果关系数据模型发生变化(如更改表结构),就必须手动修改程序里所有
相关的sql语句,增加了维护软件的难度.

如果sql语句有语法错误,编译是不能检查这种错误,只有运行时才能发现错误,增加了程序的调试难度.

EJB:	我们必须遵守复杂的J2EE规范,Hibernate不强迫必须满足特定的规范.

EJB只能运行在EJB容器中,Hibernate可以运行在任何java环境中.

2级缓存:
session缓存:被称为Hibernate的第一级缓存.它存放被单前工作单元加载的对象.
sessionFactory缓存:
被称为Hibernate的第二级缓存.一个实例对应一个数据存储源.它是线程安全的,是重量级的.它需要一个很大的缓存,用来存放预定义的SQL语句以及映射元数据等.