标签：延迟 查询 filter 基于 extends .class get intern 常量
ssh整合-xml方式：
1.需要记住的三个jar包：
spring-web-4.2.4.RELEASE.jar ---保证项目启动时就实例化spring配置的对象(通过一个servletContext监听器ContextLoaderListener实现)，保证整个项目只有一个工厂。
struts2-spring-plugin-2.3.24.jar ---解决了struts2和spring的整合问题，将struts2中的action交给spring创建
spring-orm-4.2.4.RELEASE .jar ---解决hibernate和spring的整合，将sessionfactory交给spring创建(通过一个FactoryBean接口实现类实现)，并且hibernate的事务也由spring事务管理器管理
2.FactoryBean接口 //对象工厂，可以存入对象。这个接口中的方法有getObject(); getObjectType(); ...这两个方法获取对象和对象class
如果让一个类实现这个接口，然后将这个类交给spring管理(在applicationContext.xml中配置这个bean)，如：
<bean id="car" class="...CarFactoryBean"></bean>
那么在获取bean对象时：
a. 如果通过applicationContext对象调用getBean();获取：
ac.getBean("car");
此时，底层发现CarFactoryBean实现了FactoryBean接口，就会调用其中getObject();方法获取到这个类中的对象
b. 如果通过ac.getBean(Car.class);这种方式获取bean：
那么，会调用CarFactoryBean中的getObjectType();如果发现这个方法返回的是Car.class，则会接下来调用getObject()获取对象;
注意：
@autowire //这种方式是在spring容器中找到Car或其实现类实现注入的，相当于调用ac.getBean(Car.class);获取，因此使用FactoryBean获取时要重写getObjectType();
private Car car;
3.spring的hibernate整合，配置文件 //原理：通过factoryBean方式让spring来管理sessionFactory
方式一：LocalSessionFactoryBean注入configLocation方式 //LocalSessionFactoryBean实现了FactoryBean和initialize
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="configLocation" value="classpath:hibernate.cfg.xml"></property> //这个属性传入的是hibernate配置文件类路径
</bean>
原理： 1. 实例化LocalSessionFactoryBean时会注入configLocation，
2. 由于LocalSessionFactoryBean底层实现了initialize，会调用初始化方法，根据配置文件路径加载和解析hibernate.cfg.xml配置文件，并创建SessionFactory对象
3. 在获取sessionFactory时会调用getObject();方法获取
缺点：依然需要hibernate.cfg.xml文件
方式二：配置LocalSessionFactoryBean，注入hibernate.cfg.xml中的连接池、属性等 //不再需要hibernate.cfg.xml文件
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean"> //配置LocalSessionFactoryBean
<property name="dataSource" ref="dataSource"></property> //需要注入连接池
<property name="hibernateProperties"> //注入其他属性，hibernateProperties底层为properties集合
<value>
hibernate.show_sql=true
hibernate.format_sql=true
hibernate.dialect=org.hibernate.dialect.MySQLDialect
hibernate.hbm2ddl.auto=update
</value>
</property>
<property name="hibernateProperties"> //也可通过这种方式注入其他属性
<props>
<prop key="hibernate.show_sql">true</prop>
</props>
<property>
<property name="mappingDirectoryLocations" value="classpath:cn/itheima/domain"></property> //配置映射文件（xxx.hbm.xml）路径，四种方式
<property name="mappingLocations" value="classpath:cn/itheima/domain/User.hbm.xml"></property>
<property name="mappingResources" value="cn/itheima/domain/User.hbm.xml"></property>
<property name="mappingJarLocations"></property>
</bean>
4.spring的hibernate整合，Dao的操作：
让Dao继承HibernateDaoSupport，只需要注入SessionFactory就可以获得HibernateTemplate //这里的HibernateDaoSupport类似于JdbcDaoSurport，封装了HibernateTemplate
<bean id="userDao" class="cn.itheima.dao.UserDaoImpl">
<property name="sessionFactory" ref="sessionFactory"/> //dao中注入sessionFactory
</bean>
使用hibernateTemplate实现增删改查 //底层通过session实现，得到的是getCurrentSession(); 事务默认为只读
this.getHibernateTemplate().save(user) //底层调用session.save(user)
this.getHibernateTemplate().update(user) //底层调用session.update(user)
this.getHibernateTemplate().del(user) //底层调用session.del(user)
this.getHibernateTemplate().get(User.class,id) //底层调用session.get(User.class,id)
this.getHibernateTemplate().find("hql",arg1,arg2...) //底层调用session.createQrery("hql").serParameter(...).list();
原理：
配置文件加载时创建userDao，同时注入sessionFactory，sessionFactory注入时，会直接创建HibernateTemplate对象
因此，userDao可以直接调用父类的getHibernateTemplate()来获取HibernateTemplate实现增删改查
增删改查的实现在底层均通过hibernate中的session对象实现。为getCurrentSession();得到与线程绑定的session
注意：未添加事务时有默认事务，且事务的默认为readonly，即默认只能查，不能增删改。
总结：spring整合hibernate主要包括两个方面：
1)将sessionFactory交给spring管理 //两种方式，均由spring来加载配置文件，创建sessionFactoryBean
2)dao层使用hibernateTemplate实现增删改查 //dao继承HibernateDaoSupport，注入sessionFactory实现
5.spring的hibernate整合，事务管理：
采用HibernateTransactionManager事务管理器，注入sessionFactory,其他操作（配置通知切面，<tx:advice> <aop:config>）同day3中的spring自身事务的操作：
<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
总结:基于spring自身提供的事务管理模式，只是采用的事务管理器不同
6.Spring整合struts2框架 //必须导入jar包struts2-spring-plugin-2.3.24.jar，这个jar包改变了创建Action的方式
原理：
struts2框架配置文件加载顺序
a. default.properties
b. struts-default.xml
c. struts -plugin.xm
在导入的jar包中有一个plugin的配置文件,加载时会覆盖struts2中的一个常量struts.objectFactory为spring
struts2框架默认通过ObjectFactory创建对象，由于上述常量值的改变。bean的创建由spring对象工厂SpringObjectFactory来管理
SpringObjectFactory创建对象主要方法：
public Object buildBean(String beanName, Map<String, Object> extraContext, boolean injectInternal) throws Exception {
Object o;
//这个beanName是struts2框架传入的，对应struts.xml中的class属性
//把beanName作为id判断Spring容器是否有这个id对应的bean
if (appContext.containsBean(beanName)) {
//如果找到了就直接从Spring容器获取
o = appContext.getBean(beanName);
} else {
//如果没有从Spring容器找到该id对应bean,
//就把beanName作为全类名通过反射创建对象并且注入属性
Class beanClazz = getClassInstance(beanName);
o = buildBean(beanClazz, extraContext);
}
return o;
}
总结：struts2-spring-plugin-2.3.24.jar改变了struts中action的创建方式，将action创建交给spring管理
方式一：基于spring管理action ：伪类名 //在applicationContext.xml文件中来声明action
1. 在applicationContext中配置action：
<bean id="userAction" class="cn.itheima.action.UserAction" scope="prototype"> //此处必须设置scope的属性为prototype，否则每次请求获取到的是同一个action
<property name="userService" ref="userService"/> //service的注入，必须在action中提供对应的set方法
</bean>
2. 在struts.xml中配置，将class 值修改为伪类名
<package name="default" extends="struts-default">
<action name="user_add" class="userAction" method="add"> //此处class不再是全类名，而是对应了applicationContext中的id
<result name="...">...</result>
</action>
</package>
原理：
当请求发出时，spring会根据class 的值，在applicationContext.xml中查找是否有对应的id，有则直接从applicationContext容器中获取对象
方式二：自动注入service
struts.xml中的class 直接用全类名，只需要在action中提供service的set方法
<action name="user_add" class="cn.itheima.action.UserAction" method="add"> //此处class是全类名
<result name="...">...</result>
</action>
public void UserAction extends ActionSupport{
private IUserService userService;
public void setUserService(IUserService us){ //会根据set方法的名称在applicationContext.xml中查找对应的id（userService）,并注入bean
this.userService=us;
}
}
struts.objectFactory.spring.autoWire常量的配置：
<constant name="struts.objectFactory.spring.autoWire" value="type"/> //默认值为name
默认情况下,根据action中的set方法名称，查找applicationContext.xml对应id并实现属性注入，
常量值修改为type后，会根据set方法的参数类型，在applicationContext.xml中根据这个类型查找其实现类对象并注入属性
原理：
与伪类名方式执行流程相同，会根据class属性的值，在applicationContext.xml中查找是否有对应的id，此时，找不到对应的id，会根据这个全类名创建对象，并将对象放入spring容器，
同时，根据类中的set方法注入对应的属性
总结： 本质上是将action交给spring管理，两种方式
补充：
<context:component-scan>和<context:annotation-config>的区别：
<context:component-scan> //注解扫描，做了两件事，扫描注解，创建对象放入spring容器中，让注解生效
<context:annotation-config> //使注解生效，与注解扫描的区别？
ssh整合，注解的使用
1.实体类的注解：
1)实体类注解配置：
@Entity
@Table(name="t_user")
public class User {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private int id;
private String name;
private int age;
2)applicationContext.xml中实体类的引入：
<property name="packagesToScan" value="cn.itheima.domain"></property> //与之前引入hbm.xml文件不同，在sessionFactory中注入packagesToScan，指定实体类所在的包
2.dao的注解配置：
applicationContext.xml中开启注解扫描：
<context:component-scan base-package="cn.itheima"></context:component-scan>
dao的注解配置：
@Repository
public class UserDaoImpl extends HibernateDaoSupport implements IUserDAO {
@Autowired
public void setSf(SessionFactory sf){ //将sessionFactory注入父类，前提：applicationContext.xml中配置LocalSessionFactoryBean
super.setSessionFactory(sf);
}
3.service的注解配置，事务的添加
1)service注解配置：
@Service //注解方式配置UserServiceImpl
public class UserServiceImpl implements IUserService{
@Autowired //注入dao
private IUserDAO userDao;
2)事务管理的实现：
A.applicationContext.xml:
<bean id="tm" class="org.springframework.orm.hibernate5.HibernateTransactionManager"> //配置事务管理器
<property name="sessionFactory" ref="sessionFactory"></property> //要注入sessionFactory
</bean>
<tx:annotation-driven transaction-manager="tm"/> //配置注解驱动，需要传入事务管理器
B.类上或方法上加事务管理注解：
@Transactional
public class UserServiceImpl implements IUserService{
4.action的注解配置： //采用的是全类名方式完成整合
只需要在配置好struts中的配置的基础上，在private IUserService userService;加上@Autowired即可
@ParentPackage("struts-default")
public class UserAction extends ActionSupport implements ModelDriven<User>{
private User user=new User();
@Autowired //只需要添加这个注解即可
private IUserService userService;
@Override
public User getModel() {
return user;
}
@Action(value="user_add",results={@Result(name="success",location="/success.jsp")}) //在此处其实有一个className属性，相当于配置文件中的class,默认为UserAction全类名
public String add(){
userService.add(user);
return SUCCESS;
}
}
原理： 请求发出时，spring会代替struts2创建action对象（根据xml中的class属性值或者注解中@Action中的className属性），有一下两种方式
A.默认的全类名方式： //className属性取默认值
由于@Action中的className默认值为UserAction全类名，因此spring会根据这个全类名，创建UserAction对象并交给spring容器管理，同时根据类型注入userService。
因此在spring容器中必须有userService对象存在，即在applicationContext中必须配置这个对象
B.让程序以伪类名方式创建: //麻烦，不建议使用 //设置className属性
1)设置@Action中的className属性为userAction。此时，会根据这个名称，在applicationContext中获取对象，因此需手动将userAction交给spring容器管理：
2)在UserAction类上配置注解，实现action由spring创建并管理：
@Component //默认的id为userAction
@Scope("prototype") //必须配置这个属性
public class UserAction extends ActionSupport implements ModelDriven<User>{
5.no session 的问题：配置一个filter
问题产生的原因：默认情况下，session是在dao层通过getCurrentSession();获取到，这个session在service层事务关闭时会自动关闭。
当在dao层进行延迟查询时，不会马上从数据库查询数据。当要使用这些数据时，会再action层获取，此时会使用到session，由于session在service已经关闭，会出现no session异常
<filter> //必须放在struts2过滤器之前
<filter-name>openSessionInView</filter-name>
<filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>openSessionInView</filter-name>
<url-pattern> /* </url-pattern> // */
</filter-mapping>
原理：
请求发出时，会先被这个过滤器拦截，在这个过滤器中，会从spring容器中获取到sessionFactory,并调用openSession()获取session这个session会被放到sessionHolder中，被dao拿到。
这个过滤器走完后会执行struts2过滤器，以及action。service，dao层的操作，此时在service层执行完，事务提交时不会再关闭session，而是再action执行完后由过滤器关闭session
如果请求为action请求，struts2过滤器不会放行，因此必须把openSessionInView过滤器放在struts2过滤器之前
//sturts 会拦截url,不会拦截uri(指定某个网络资源)
标签：延迟 查询 filter 基于 extends .class get intern 常量
原文地址：https://www.cnblogs.com/liuxuelin/p/9973735.html
