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

2013年04月18日 01:22 阅读 52 Spring

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

ApplicationContex  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语句以及映射元数据等.
还没有评论!