关于SSM与SSH框架的一些问题

一.Hibernate与Mybatis的区别

    1.开发方面

        在项目开发过程中，就速度而言：

            Hibernate开发中，sql语句已经被封装，可以被直接使用，加快系统开发；

            Mybatis属于半自动化，sql需要手工完成，稍微繁琐；

        但是，如果对于庞大复杂的系统项目来说，复杂语句较多，使用Mybatis比较好，下边将会提到。

    2.sql优化方面

        Hibernate自动生成sql时有些语句较为繁琐，会多消耗一些性能；

        Mybatis手动编写sql，可以避免不必要的查询，提高系统性能；

    3.对象管理比对

        Hibernate时完整的对象——关系映射框架，开发工程中，无需过多的关注底层的实现，只要去管理对象即可；

        Mybatis要自行管理映射关系；

    4.缓存方面

        Hibernate的二级缓存配置在SessionFactory生成的配置文件中进行详细的配置，然后再在具体的表——对象映射中配置缓存；

        Mybatis的二级缓存配置都是在每个具体的表——对象映射中进行详细配置，这样针对不同的表可以定义不同的缓存机制，并且Mybatis可以在命名空间中共享相同的缓存配置和实例。

      Hibernate具有良好的管理机制，用户不需要关注sql，如果二级缓存出现脏数据，系统会保存；Mybatis在使用时需要谨慎，避免缓存Cache的使用。

    总之

  Hibernate的优势：

        1.DAO层开发比Mybatis简单，Mybatis需要维护sql和结果映射。

        2.对对象的维护和缓存比较好，对CRUD的对象的维护更为方便。

        3.数据库移植性比较好，而Mybatis不同的数据库需要写不同的sql，移植性较差。

        4.有更好的二级缓存机制，可以使用第三方缓存，Mybatis本身提供的缓存机制不佳。

  Mybatis的优势：

        1.可以进行更为细致的sql优化，可以减少查询字段。

        2.对新手而言较为容易掌握。

二.springMVC与struts2的区别

    框架机制

        1、Struts2采用Filter（StrutsPrepareAndExecuteFilter）实现，SpringMVC（DispatcherServlet）则采用Servlet实现。
        2、Filter在容器启动之后即初始化；服务停止以后坠毁，晚于Servlet。Servlet在是在调用时初始化，先于Filter调用，服务停止后销毁。

    拦截机制

        1、Struts2

            a、Struts2框架是类级别的拦截，每次请求就会创建一个Action，和Spring整合时Struts2的ActionBean注入作用域是原型模式prototype（否则会出现线程并发问题），然后通过setter，getter吧request数据注入到属性。
            b、Struts2中，一个Action对应一个request，response上下文，在接收参数时，可以通过属性接收，这说明属性参数是让多个方法共享的。
            c、Struts2中Action的一个方法可以对应一个url，而其类属性却被所有方法共享，这也就无法用注解或其他方式标识其所属方法了
 
        2、SpringMVC
            a、SpringMVC是方法级别的拦截，一个方法对应一个Request上下文，所以方法直接基本上是独立的，独享request，response数据。而每个方法同时又何一个url对应，参数的传递是直接注入到方法中的，是方法所独有的。处理结果通过ModeMap返回给框架。

            b、在Spring整合时，SpringMVC的Controller Bean默认单例模式Singleton，所以默认对所有的请求，只会创建一个Controller，有应为没有共享的属性，所以是线程安全的，如果要改变默认的作用域，需要添加@Scope注解修改。

三.spring采用了那些设计模式

  

    1. 简单工厂

        又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。

        简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。

        Spring中的BeanFactory就是简单工厂模式的体现，根据传入一个唯一的标识来获得Bean对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。

 

 

    2. 工厂方法（Factory Method）

        定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

        Spring中的FactoryBean就是典型的工厂方法模式。如下图：

 

    3. 单例（Singleton）

        保证一个类仅有一个实例，并提供一个访问它的全局访问点。

        Spring中的单例模式完成了后半句话，即提供了全局的访问点BeanFactory。但没有从构造器级别去控制单例，这是因为Spring管理的是是任意的Java对象。

 

    4. 适配器（Adapter）

        将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

        Spring中在对于AOP的处理中有Adapter模式的例子，见如下图：

        由于Advisor链需要的是MethodInterceptor（拦截器）对象，所以每一个Advisor中的Advice都要适配成对应的MethodInterceptor对象。

 

 

    5.包装器（Decorator）

        动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。

        Spring中用到的包装器模式在类名上有两种表现：一种是类名中含有Wrapper，另一种是类名中含有Decorator。基本上都是动态地给一个对象添加一些额外的职责。

 

 

    6. 代理（Proxy）

        为其他对象提供一种代理以控制对这个对象的访问。

        从结构上来看和Decorator模式类似，但Proxy是控制，更像是一种对功能的限制，而Decorator是增加职责。

        Spring的Proxy模式在aop中有体现，比如JdkDynamicAopProxy和Cglib2AopProxy。

 

 

    7.观察者（Observer）

        定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

        Spring中Observer模式常用的地方是listener的实现。如ApplicationListener。

 

 

 

    8. 策略（Strategy）

        定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

        Spring中在实例化对象的时候用到Strategy模式，见如下图：

        在SimpleInstantiationStrategy中有如下代码说明了策略模式的使用情况：

 

 

 

    9.模板方法（Template Method）

        定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。Template Method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

        Template Method模式一般是需要继承的。这里想要探讨另一种对Template Method的理解。Spring中的JdbcTemplate，在用这个类时并不想去继承这个类，因为这个类的方法太多，但是我们还是想用到JdbcTemplate已有的稳定的、公用的数据库连接，那么我们怎么办呢？我们可以把变化的东西抽出来作为一个参数传入JdbcTemplate的方法中。但是变化的东西是一段代码，而且这段代码会用到JdbcTemplate中的变量。怎么办？那我们就用回调对象吧。在这个回调对象中定义一个操纵JdbcTemplate中变量的方法，我们去实现这个方法，就把变化的东西集中到这里了。然后我们再传入这个回调对象到JdbcTemplate，从而完成了调用。这可能是Template Method不需要继承的另一种实现方式吧。

        以下是一个具体的例子：

        JdbcTemplate中的execute方法：

        JdbcTemplate执行execute方法：

四.spring中AOP主要用来做什么

      AOP是面向切面编程，也就是说面向某个功能模块编程，典型的应用就是Spring的声明式事务，
      Spring的AOP事务解析：
        在以前的事务管理是要融合在逻辑代码中的，在逻辑代码中决定事务是否提交或者回滚，这样很容易造成代码难以维护，代码冗余，  但是使用spring的声明式事务后，只需要在数据库处理方法上注解事务，就可以对操作进行管理，事务的设置和逻辑代码分开，容易维护。

       面向切面编程，例如某个功能点，我们只需抽取横切关注点，然后让需要处理这些功能点的方法来使用代理的方式调用

五.spring注入bean的方式有哪些

    1.使用属性的setter方法注入  这是最常用的方式

    首先要配置被注入的bean，在该bean对应的类中，应该有要注入的对象属性或者基本数据类型的属性。例如：为UserBiz类注入UserDAO，同时为UserBiz注入基本数据类型String，那么这时，就要为UserDAO对象和String类型设置setter方法.，用于进行依赖注入。

      如何配置该bean呢？

<bean id="userBiz" class="com.text.biz.impl.UserBizImpl">

<property name="userDao">

<ref>userDao</ref>

</property>

</bean>

     2.使用构造器注入

    第一，在PersonBiz类中注入PersonDAO和一个String类型的数据；在该类中，不用为PersonDAO属性和String数据类型的属性设置setter方法，但是需要生成该类的构造方法；如下：

public class PersonBizImpl implements PersonBiz {

// 声明"依赖对象"PersonDAO

PersonDAO personDao = null;

// 声明"依赖的基本数据类型"

String str = null;

// 生成无参构造方法

public PersonBizImpl() {

super();

}

// 生成带参构造方法

public PersonBizImpl(PersonDAO personDao, String str) {

super();

this.personDao = personDao;

this.str = str;

}

public void addPerson() {

this.personDao.addPerson();

System.out.println(str);

}

}

    第二，在配置文件中配置该类的bean，并配置构造器，在配置构造器中用到了<constructor-arg>节点，该节点有四个属性：

· index是索引，指定注入的属性，从0开始，如：0代表personDao，1代表str属性；

· type是指该属性所对应的类型，如Persondao对应的是com.aptech.dao.PersonDAO；

· ref 是指引用的依赖对象；

· value 当注入的不是依赖对象，而是基本数据类型时，就用value；

    如下：

<!-- 利用构造器配置依赖注入 -->

<bean id="personDao" class="com.aptech.dao.impl.PersonDAOImpl"></bean>

<bean id="personBiz" class="com.aptech.biz.impl.PersonBizImpl">

<constructorarg index="0" type="com.aptech.dao.PersonDAO"ref="personDao"></constructor-arg>

<constructor-arg index="1" value="Spring学习"></constructor-arg>

</bean>

     3.使用Filed注入（用于注解方式）

    在Spring中，注入依赖对象可以采用手工装配或自动装配，在实际应用开发中建议使用手工装配，因为自动装配会产生许多未知情况，开发人员无法预见最终的装配结果。

    手工装配依赖对象又分为两种方式：

    一种是在XML文件中，通过在bean节点下配置；如上面讲到的使用属性的setter方法注入依赖对象和使用构造器方法注入依赖对象都是这种方式。

    另一种就是在java代码中使用注解的方式进行装配，在代码中加入@Resource或者@Autowired、

    怎样使用注解的方式来为某个bena注入依赖对象呢？

    首先，我们需要在Spring容器的配置文件applicationContext.Xml文件中配置以下信息,该信心是一个Spring配置文件的模板：

<?xml version="1.0" encoding="UTF-8"?>

<beans

xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:p="http://www.springframework.org/schema/p"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-2.5.xsd

">

</beans>

注意：只有配置了红色部分的代码才可以引入注解的命名空间，否则报错。  以上的配置隐式的注册了多个对注释进行解析的处理器：AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、PersistenceAnnotationBeanPostProcessor等。

其次，在配置文件中打开<context:annotation-config>节点，告诉Spring容器可以用注解的方式注入依赖对象；其在配置文件中的代码如下：

<beans>

……

<context:annotation-config></context:annotation-config>

……

</beans>

    第三，在配置文件中配置bean对象，如下：

<bean id="userDao" class="com.springtest.dao.impl.UserDAOImpl"></bean>

<bean id="userBiz" class="com.springtest.biz.impl.UserBizImpl"></bean>

    第四，在需要依赖注入的BIZ类中，声明一个依赖对象，不用生成该依赖对象的setter方法，并且为该对象添加注解：

public class UserBizImpl implements UserBiz {

@Resource(name="userDao")

private UserDAO userDao = null;

public void addUser() {

this.userDao.addUser();

}

}

    其中，在Java代码中可以使用@Autowired或@Resource注解方式进行Spring的依赖注入。两者的区别是：@Autowired默认按类型装配，@Resource默认按名称装配，当找不到与名称匹配的bean时，才会按类型装配。

    比如：我们用@Autowired为上面的代码UserDAO接口的实例对象进行注解，它会到Spring容器中去寻找与UserDAO对象相匹配的类型，如果找到该类型则将该类型注入到userdao字段中；

    如果用@Resource进行依赖注入，它先会根据指定的name属性去Spring容器中寻找与该名称匹配的类型，例如：@Resource(name="userDao")，如果没有找到该名称，则会按照类型去寻找，找到之后，会对字段userDao进行注入。

    通常我们使用@Resource。

    使用注解注入依赖对象不用再在代码中写依赖对象的setter方法或者该类的构造方法，并且不用再配置文件中配置大量的依赖对象，使代码更加简洁，清晰，易于维护。

    在Spring IOC编程的实际开发中推荐使用注解的方式进行依赖注入。

    依赖注入—自动装配 Spring中提供了自动装配依赖对象的机制，但是在实际应用中并不推荐使用自动装配，因为自动装配会产生未知情况，开发人员无法预见最终的装配结果。 自动装配是在配置文件中实现的，如下： <bean id="***" class="***" autowire="byType"> 只需要配置一个autowire属性即可完成自动装配，不用再配置文件中写<property>,但是在类中还是要生成依赖对象的setter方法。 Autowire的属性值有如下几个： · byType 按类型装配  可以根据属性类型，在容器中寻找该类型匹配的bean，如有多个，则会抛出异常，如果没有找到，则属性值为null； · byName 按名称装配  可以根据属性的名称在容器中查询与该属性名称相同的bean，如果没有找到，则属性值为null； · constructor 与byType方式相似，不同之处在与它应用于构造器参数，如果在容器中没有找到与构造器参数类型一致的bean，那么将抛出异常； · autodetect 通过bean类的自省机制(introspection)来决定是使用constructor还是byType的方式进行自动装配。如果发现默认的构造器，那么将使用byType的方式。

六.什么是IOC，什么是依赖注入

    IOC即控制反转，意思是原本我们需要一个对象时，自己要去new一个对象，但是我们使用spring时，需要什么对象，就告诉spring，spring就会给你这个对象，控制从“我们”手里到了spring那里，这即控制反转。

    依赖注入是IOC的一种实现形式，组件不做定位查询，只提供普通的Java方法让容器去决定依赖关系。容器全权负责的组件的装配，它会把符合依赖关系的对象通过JavaBean属性或者构造函数传递给需要的对象。通过JavaBean属性注射依赖关系的做法称为设值方法注入(Setter Injection)；将依赖关系作为构造函数参数传入的做法称为构造器注入（Constructor Injection）