spring的使用-ssh整合

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对象时：

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

<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>

</props>

<property name="mappingDirectoryLocations" value="classpath:cn/itheima/domain"></property> //配置映射文件（xxx.hbm.xml）路径，四种方式

</bean>

4.spring的hibernate整合，Dao的操作：

让Dao继承HibernateDaoSupport，只需要注入SessionFactory就可以获得HibernateTemplate //这里的HibernateDaoSupport类似于JdbcDaoSurport，封装了HibernateTemplate

<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>

总结:基于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 值修改为伪类名

<action name="user_add" class="userAction" method="add"> //此处class不再是全类名，而是对应了applicationContext中的id

</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是全类名

</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(指定某个网络资源)

posted @ 2018-11-17 13:58 foreast 阅读(331) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

spring的使用-ssh整合

公告