复习2.txt

Java大部分的基础知识,EJB3,EJB2,WEBSERVICE,SOAP,JMS,MQ,还有些面试题

spring:
	1、spring原理	
		spring的最大作用ioc/di,将类与类的依赖关系写在配置文件中，
		程序在运行时根据配置文件动态加载依赖的类，降低的类与类之间
		的藕合度。它的原理是在applicationContext.xml加入bean标记,
		在bean标记中通过class属性说明具体类名、通过property标签说明
		该类的属性名、通过constructor-args说明构造子的参数。其一切都是
		返射，当通过applicationContext.getBean("id名称")得到一个类实例时，
		就是以bean标签的类名、属性名、构造子的参数为准，通过反射实例对象，
		唤起对象的set方法设置属性值、通过构造子的newInstance实例化得到对象。
		正因为spring一切都是反射，反射比直接调用的处理速度慢，所以这也是spring
		的一个问题。
		spring第二大作用就是aop，其机理来自于代理模式，代理模式
		有三个角色分别是通用接口、代理、真实对象 
		代理、真实对象实现的是同一接口，将真实对象作为
		代理的一个属性，向客户端公开的是代理，当客户端
		调用代理的方法时，代理找到真实对象，调用真实对象
		方法，在调用之前之后提供相关的服务，如事务、安全、
		日志。其名词分别是代理、真实对象、装备、关切点、连接点。
	2、动态代理:不用写代理类，虚拟机根据真实对象实现的接口产生一个类，通过
		    类实例化一个动态代理，在实例化动态代理时将真实对象
		    及装备注入到动态代理中，向客户端公开的是动态代理，
		    当客户端调用动态代理方法时，动态代理根据类的返射得
		    到真实对象的Method,调用装备的invoke方法，将动态代理、
		    Method、方法参数传与装备的invoke方法，invoke方法在唤
		    起method方法前或后做一些处理。	
		    1、产生动态代理的类:
		    	java.lang.refect.Proxy
		    2、装备必须实现InvocationHandler接口实现invoke方法
	3、反射
		什么是类的返射?
			通过类说明可以得到类的父类、实现的接口、内部类、构造函数、方法、属性
			并可以根据构造器实例化一个对象，唤起一个方法，取属性值，改属性值。
		如何得到一个类说明?
			Class cls=类.class;
			Class cls=对象.getClass();
			Class.forName("类路径");
		如何得到一个方法并唤起它?
			Class cls=类.class;
			Constructor cons=cls.getConstructor(new Class[]{String.class});
			Object obj=cons.newInstance(new Object[]{"aaa"});
			Method method=cls.getMethod("方法名",new Class[]{String.class,Integer.class});
			method.invoke(obj,new Object[]{"aa",new Integer(1)});	
	4、spring的三种注入方式是什么?
		setter
		interface
		constructor
	5、spring的核心接口及核类配置文件是什么?
		FactoryBean:工厂bean主要实现ioc/di
		
		ApplicationContext ac=new FileXmlApplicationContext("applicationContext.xml");
		Object obj=ac.getBean("id值");
		
		applicationContext.xml
	6、spring配置文件中的主要标签是什么?写一个小实例?
		<beans>
			<bean id="customer" class="dao.Customer" scope="singleton/prototype/request/session" init-method="init1" destroy-method="destroy1()">
				<property name="customerName">
					<value>张三</value>
				</property>
				<property name="address">
					<ref local="address"/>
				</property>
			</bean>
			<bean id="address" class="dao.Address">
				<property name="addressName">
					<value>深圳</value>
				</property>
			</bean>
		</beans>
	7、什么是spring的ioc?
		强依赖关系:
			List list=new ArrayList();
		较弱依赖关系:通过工厂产生具体的实现类返回接口，增加一个产品
			时，只需修改工厂。
			DocumnetBuilderFactory dbf=DocumentBuilderFactory.newInstance();
			DocumentBuilder db=dbf.newDocumentBuilder();
		最弱依赖关系:
			将类与类依赖关系写到配置文件中，
			程序在运行时动态的加载依赖的类，将一种强依赖关系转化为弱依赖关系。
			是一个超级工厂,spring就是一个超级工厂。	
	8、aop是什么?作用?名称及特点?
		aop是面向方面编程是对oop的一种补充，不可以代替oop，共提供一些通用的服务如事务、安全、日志
		aop的名词:
			拦截器:代理
			装备:处理类
			目标对象:真实对象
			连接点:连接的是属性还是方法，一般方法
			关切点:要拦截方法的条件
	9、描述struts&spring&hibernate联合的配置文件如何实现?
		sh(spring&hibernate)
		dataSource
		sessionFactory
		userDao:(实现类不是接口)	public class UserDaoImpl extends HibernateDaoSupport implements UserDao
			sessionFactory
		facade:(实现类不是接口)
			userDao
		transactionManager:HibernateTransactionManager
		abstractProxy(abstract="true"):TransactionProxyFactoryBean 
			transactionManager
			transactionAttributes
					PROPRAGRAM_REQUIRED,readOnly
		facadeProxy(parent="abstractProxy"):
			target
				facade
		ss(struts&spring)
			在strust中加入一个插件
				类:ContextLoaderPlugIn
				属性:
					contextConfigLocation=/WEB-INF/applicationContext.xml
			struts-config.xml中的每一个action的type不再指向真正的Action，而
				DelegatingActionProxy
			applicationContext.xml
				<bean name="/insert" class="struts.action.InsertAction">
					<property name="facade">
						<ref local="facadeProxy"/>
					</property>
				</bean>
	10、jdbc、hibernate、ibatis各有什么特点及区别
		jdbc(手动):手动写sql，
			在执行dml时手动将对象的每一个值给PreparedStatement，再执行相关的操作
			在执行dql时返回一个ResultSet，手动将ResultSet中的每一个值
				封装到数据类中			
		ibatis(半自动):手动写sql
			在执行dml时直接传一个对象进行增删改
			在执行dql时直接返回一个对象，不用手动封装
		hibernate(全自动):自动生成sql
			在执行dml时直接传一个对象进行增删改
			在执行dql时直接返回一个对象，不用手动封装
	11、什么时候用ibatis:
		1、对性能要求很高，要有高度优化的sql时
		2、没有提供整个表结果，提供了几个select语句
		3、大量的业务写在存储过程中 
	12、ibatis的核心类
		SqlMapClientBuilder:加载sqlmapclient.xml文件及具体的映射文件
		SqlMapClient:相当于hibernate中的session，做数据的增删改查
		
		Reader reader=Resources.getResourceAsReader("路径");
		SqlMapClient smc=SqlMapClientBuilder.buildSqlMapClient(reader);
		smc.queryforObject("命名空间.标签名",Object o);
		smc.queryforList("命名空间.标签名",Object o);
		smc.delete("命名空间.标签名",Object o);
		smc.update("命名空间.标签名",Object o);
		smc.insert("命名空间.标签名",Object o);		
	13、ibatis的核心配置文件是什么?
		sqlmapclient.xml:说明数据库连接及具体o/r mapping
		buy.xml:具体的o/r mapping说明
	14、描述struts&spring&ibatis联合的配置文件如何实现?
		si(spring ibatis)
			dataSoruce:在sqlmapclient中去掉数据库连接的相关信息
			sqlMapClient:SqlMapClientFactoryBean
				configLocation 
					classpath:sqlmapclient.xml
					/WEB-INF/sqlmapclient.xml
			customerDao
				dataSource
				sqlMapClient
			buyDao 
				dataSource
				sqlMapClient
			facade
				buyDao
				customerDao
			transactionManager:DataSourceTransactionManager
			abstractProxy:TransactionProxyFactoryBean abstract="true"
				transactionManager
				transacctionAttributes
					PROPAGATION_REQUIRED
					PROPAGATION_REQUIRED,readOnly
			facadeProxy:parent="abstractProxy"
				target:facade	
	15、struts1.x与spring的整合
		1、在struts-config.xml中加入插件加载applicationContext.xml文件
		2、修改struts-config.xml文件中的action标签，type属性指定的
		   不再是具体action而是DelegationActionProxy
		3、在applicationContext.xml中加入bean标签,
		   说明具体的action,注意name="url"。
	16、struts2.0&spring2&hibernate3.2组合
		hibernate实现:
			用hibernate的annotation(注解)，不写xml文件，更为的方便。
			在hibernate.cfg.xml中加载的不是xml文件，而是具体的有注解的hibernate类
				<sessionFactory>
					<mapping resource="hibernate/customer.hbm.xml"/>
					<mapping class="hibernate.Buy"/>
				</sessionFactory>
			如果是纯的hibernate环境，不能通过Configuration加载，而是通过AnnotationConfiguration加载
		与spring的整合:
			hibernate注解与spring组合时，不能用以前的方式，要在src根目录下加入hibernate.cfg.xml文件:
			   spring中的具体内容:
				  <bean id="sessionFactory"
						class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
						<property name="dataSource">
							<ref bean="dataSource" />
						</property>
						<property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration"></property><!--说明不再是Configuration而是AnnotationConfiguation-->
						<property name="configLocation" value="classpath:hibernate.cfg.xml"></property><!--说明hibenate.cfg.xml所在的位置-->
						<!--
						<property name="hibernateProperties">
							<props>
								<prop key="hibernate.dialect">
									org.hibernate.dialect.SQLServerDialect
								</prop>
							</props>
						</property>		
						<property name="mappingResources">
							<list>
								<value>hibernate/buy.hbm.xml</value>
								<value>hibernate/customer.hbm.xml</value>
							</list>
						</property>-->
				 </bean>
		 hibernate.cfg.xml中的配置:
			 <session-factory>		    	
			        <mapping class="hibernate.Buy"/>
			        <mapping class="hibernate.Customer"/>
		    	</session-factory>
		 struts2的整合:
		 	1、在web.xml中加入监听器加载applicationContext.xml文件
			2、在applictionContext.xml说明真正的action
				<bean id="login" class="action.LoginAction">
					<property name="facade">
						<ref local="facade"/>
					</property>
				</bean>
			2、修改struts.xml中的action标签，其class属性不再是具体的Action,而是applictionContext.xml中
			    真正Action对应的id名
			    <action name="login" class="login">
			    	<result></result>
			    	<result name="error">error.jsp</resutl>
			    </action>
	17、spring中的事务声明，因xml格式说明用了schema，
		所以支持命名空间，使用了AspectJ语法
		<!--说明事务策略,说明拦截那些方法-->
			<tx:advice id="facadeTransactonMethod" transaction-manager="transactionManager">
				<tx:attributes>
					<tx:method name="select*" read-only="true"/>
					<tx:method name="*"/>
				</tx:attributes>
			</tx:advice>
		<!--拦截那些类-->
			<aop:config>
				<!--关切那些类-->
				<aop:pointcut id="facadeClass" expression="execution(* facade.*.*(..))"/>
				<aop:advisor advice-ref="facadeTransactonMethod" pointcut-ref="facadeClass"/>
			</aop:config>
	18、spring1.2及spring2.0在aop事务上的区别:
		spring1.2事务处理实现
			1、写一个抽象的代理bean，说明TransactionProxyBeanFactory
			   类，transactionManager装备,transationAttributes连接点，
			   当一个业务类需要一个代理必须写一个bean，通过target指定
			   具体的代理，有多少业务类就要写多少个代理bean，这样appl
			   icationContext.xml会变得很大。
			 2、支持命名空间,可以直接指定一个包或几个包中的
			    所有类与事务策略相对应，不管有多少类，可以做通用配置,
			    减少类的数量。
			    spring2.0也支持注解的事务声明,具体实现需要两步
			    	1、在applictionContext.xml中加入<tx:annotation-driven/>
			    	2、需要在方法前加入如下语句
			    		@Transactional(readOnly=false,propagation=Propagation.REQUIRED)说明事务规则。
	19、事务的特点:
		原子性:要么全成功，要么全失败
		一致性:保证一人业务方法内法，业务相关的处理全涉及到。
		隔离性:事务之间不影响。
		持久性:保存到数据库中
	20、事务的实现
		1、代码式
			con.setAutocommit(false);
			con.commit();
			
			Transaction trans=con.beginTransaction();
			trans.commit();
		2、声明式
			通过xml配置文件说明，不写代码spring的aop
	21、事务的选择方式:
		1、required_new:不管有没有,重新产生一个新的事务，有则挂起。
		2、required(默认):有则用已有的，没有则产生一个新的。
		3、mandatory:前面必须有事务，没有则报错
		4、supports:有则用，没有则不用
		5、not_supported:有则挂起,没有不用
		6、never:有则报错，没有不报错