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

迷南。 2022-02-05 00:45 226阅读 0赞

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>
    	
    	
    	<bean id="simple" class="lianxi.Simple">
    		
    		<property name="say">
    			<value>Hello World!</value>
    		</property>
    	</bean>
    
    	<bean id="demo" class="lianxi.Demo">
    		
    		<property name="tall">
    			<value>happay new year !</value>
    		</property>
    	</bean>
    
    	<bean id="db" class="lianxi.DB">
    		
    		
    		<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 id="paramSingle" class="lianxi.ParamSingle" factory-method="getInstance">
    		<constructor-arg>
    			<value>Hello World !</value>
    		</constructor-arg>
    		
    		<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语句以及映射元数据等.