`

struts spring hibernate配置文件

阅读更多
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
  IndexService service = (IndexService)ctx.getBean("indexServcie");
  service.saveDao();
AnnotationConfiguration config = new AnnotationConfiguration();
  SessionFactory sf = config.configure().buildSessionFactory();
  Session session = sf.openSession();
  session.beginTransaction();
  List<MSub> subs = session.createQuery("from MSub s left join fetch s.big b").list();
  
  for(MSub sub:subs){
   System.out.println(sub.getName());
  }
  session.getTransaction().commit();
  session.close();
  sf.close();
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
	http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
	<welcome-file-list>
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>

	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
		<!-- default: /WEB-INF/applicationContext.xml -->
	</listener>

	<context-param>
		<param-name>contextConfigLocation</param-name>
		<!-- <param-value>/WEB-INF/applicationContext-*.xml,classpath*:applicationContext-*.xml</param-value>  -->
		<param-value>classpath:beans.xml</param-value>
	</context-param>
	
	
	<filter>
		<filter-name>encodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>GBK</param-value>
		</init-param>
	</filter>
	
	<filter-mapping>
		<filter-name>encodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	
	<filter>
		<filter-name>openSessionInView</filter-name>
		<filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
		<init-param>
			<param-name>sessionFactoryBeanName</param-name>
			<param-value>sf</param-value>
		</init-param>
	</filter>
	
	<filter-mapping>
		<filter-name>openSessionInView</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	
	<filter>
		<filter-name>struts2</filter-name>
		<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
	</filter>

	<filter-mapping>
		<filter-name>struts2</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	
	
	
	

</web-app>

 

 

<?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:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	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
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx 
           http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
    <!-- Annotation的配置 -->
	<context:annotation-config />
	<!-- Annotation的Bean注入 -->
	<context:component-scan base-package="com.bjsxt" />

	<!-- 
		<bean id="dataSource"
		class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		
		
		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://localhost:3306/spring" />
		<property name="username" value="root" />
		<property name="password" value="bjsxt" />
		</bean>
	-->

	<bean
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<value>classpath:jdbc.properties</value>
		</property>
	</bean>
	<!-- 连接数据库 -->
	<bean id="dataSource" destroy-method="close"
		class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName"
			value="${jdbc.driverClassName}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>
	
	
	<!-- 封装SessionFactory -->
	<bean id="sf"
		class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<!-- 
		<property name="annotatedClasses">
			<list>
				<value>com.bjsxt.model.User</value>
				<value>com.bjsxt.model.Log</value>
			</list>
		</property>
		 -->
		 <!-- Hibernate的Annotation的关系映射 -->
		 <property name="packagesToScan">
			<list>
				<value>com.bjsxt.registration.model</value>				
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">
					org.hibernate.dialect.MySQLDialect
				</prop>
				<prop key="hibernate.show_sql">true</prop>
			</props>
		</property>
	</bean>
	<!-- 把SessionFactory注入到HibernateTemplate -->
	<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
		<property name="sessionFactory" ref="sf"></property>
	</bean>

	<bean id="txManager"
		class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sf" />
	</bean>

	<aop:config>
		<aop:pointcut id="bussinessService"
			expression="execution(public * com.bjsxt.registration.service.*.*(..))" />
		<aop:advisor pointcut-ref="bussinessService"
			advice-ref="txAdvice" />
	</aop:config>

	<tx:advice id="txAdvice" transaction-manager="txManager">
		<tx:attributes>
			<tx:method name="exists" read-only="true" />
			<tx:method name="add*" propagation="REQUIRED"/>
		</tx:attributes>
	</tx:advice>

</beans>

 

 

 

 

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

    <session-factory>

        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost/hibernate</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>

        <!-- JDBC connection pool (use the built-in) -->
        <property name="connection.pool_size">1</property>

        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>

        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>
        
        <property name="format_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <property name="hbm2ddl.auto">update</property>

      
		<!-- <mapping class="com.bjsxt.hibernate.Teacher"/> -->
		
		<!-- OneToOne 单向外键关联
		<mapping class="one.to.one.Husband"/>
		<mapping class="one.to.one.Wife"/>
		 -->
		<!-- OneToOne 双向外键关联
		<mapping class="one.to.one.pk.Husband"/>
		<mapping class="one.to.one.pk.Wife"/>
		 -->
		<!-- OneToOne 联合主键关联
		<mapping class="one.to.one.composite.fk.Husband"/>
		<mapping class="one.to.one.composite.fk.Wife"/>
		 -->
		 
		 <!-- OneToOne 组合映射
		<mapping class="one.to.one.component.Husband"/>
		 -->
		<!-- ManyToOne 多对一的双向关联
		<mapping class="Many.to.One.uni.Group"/>
		<mapping class="Many.to.One.uni.User"/>
		 -->
		 
		 <!-- ManyToOne 多对一的双向关联 -->
		<mapping class="Many.to.Many.uni.Teacher"/>
		<mapping class="Many.to.Many.uni.Student"/>
		
    </session-factory>

</hibernate-configuration>

 

 

 

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c:%L - %m%n

### direct messages to file hibernate.log ###
#log4j.appender.file=org.apache.log4j.FileAppender
#log4j.appender.file.File=hibernate.log
#log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=warn, stdout

#log4j.logger.org.hibernate=info
#log4j.logger.org.hibernate=debug

### log HQL query parser activity
#log4j.logger.org.hibernate.hql.ast.AST=debug

### log just the SQL
#log4j.logger.org.hibernate.SQL=debug

### log JDBC bind parameters ###
#log4j.logger.org.hibernate.type=info
#log4j.logger.org.hibernate.type=debug

### log schema export/update ###
log4j.logger.org.hibernate.tool.hbm2ddl=debug

### log HQL parse trees
#log4j.logger.org.hibernate.hql=debug

### log cache activity ###
#log4j.logger.org.hibernate.cache=debug

### log transaction activity
#log4j.logger.org.hibernate.transaction=debug

### log JDBC resource acquisition
#log4j.logger.org.hibernate.jdbc=debug

### enable the following line if you want to track down connection ###
### leakages when using DriverManagerConnectionProvider ###
#log4j.logger.org.hibernate.connection.DriverManagerConnectionProvider=trace

 

 

 

 

 

 

<bean id="logInterceptor" class="com.bjsxt.aop.LogInterceptor"></bean>
	<aop:config>
		
		<aop:aspect id="logAspect" ref="logInterceptor">
			<aop:before method="before" pointcut="execution(public * com.bjsxt.service..*.add(..))" />
		</aop:aspect>
		

	</aop:config>

 

 

 

 

 

 

 

 

 

 

 

 

分享到:
评论

相关推荐

    struts2+spring+hibernate 配置文件

    struts2+spring+hibernate 配置文件struts2+spring+hibernate 配置文件

    spring_struts_hibernate整合开发书籍

    在书中,读者将学习到如何设置Struts2的配置文件,创建Action类,以及如何使用Struts2的拦截器来实现业务逻辑的封装。 Hibernate是Java领域中的一款优秀的对象关系映射(ORM)框架,它简化了数据库操作,使得开发者...

    图书管理系统spring+struts+hibernate

    这个文件中应包含所有必要的Java源代码、配置文件、Web应用相关的资源(如JSP页面、CSS样式、JavaScript脚本等)以及可能的项目构建脚本(如Maven的pom.xml或Gradle的build.gradle)。 总的来说,这个图书管理系统...

    Struts Spring Hibernate整合实践

    - 在 Struts 的配置文件 `struts-config.xml` 中,我们需要配置 Struts 插件来加载 Spring 上下文。 - 将 Struts 的 Action 映射配置改为使用 Spring 管理的 Bean,通常会配置一个 `&lt;action&gt;` 节点,指定对应的 ...

    Spring+struts+hibernate配置文件

    这个"Spring+struts+hibernate配置文件"的压缩包,显然是为了搭建一个基于这三大框架的Java Web项目而准备的。 Spring框架是Java开发中的核心组件,它提供了强大的依赖注入(DI)和面向切面编程(AOP)功能,帮助...

    开发基于Struts Spring Hibernate Ajax的网上信息发布平台(Struts Hibernate Spring Ajax)--Chapter1

    Spring的IoC容器使得我们可以通过配置文件轻松地管理对象间的依赖关系,而AOP则可以方便地实现如日志记录、权限检查等横切关注点。 **Hibernate**: Hibernate 是一个强大的对象关系映射(ORM)框架,它简化了数据库...

    spring整合struts2与hibernate核心配置文件

    整合SSH涉及到的主要配置文件有`struts2-spring-plugin.xml`、`spring-context.xml`以及Hibernate的相关配置文件(如`hibernate.cfg.xml`)。`struts2-spring-plugin.xml`配置Struts2与Spring的集成,确保Action类由...

    struts spring hibernate组合的留言板程序

    Spring的IOC(Inversion of Control,控制反转)容器管理着所有对象的生命周期和依赖关系,使得我们可以通过配置文件或注解声明对象及其依赖,而不是手动创建和管理。此外,Spring的AOP功能允许我们在不修改原有代码...

    struts2+hibernate+spring的配置文件

    配置 ssh2连接的详细解说,struts2+hibernate+spring整合的框架步骤及简单的知识,具体实现可以联系我

    Spring+Struts+Hibernate比较详细的整合配置方案

    - 创建Hibernate的配置文件(如`hibernate.cfg.xml`),配置数据库连接、实体类映射等。 - 定义实体类,继承Hibernate的`Serializable`接口,并使用注解或XML文件进行ORM映射。 - 创建SessionFactory,通过...

    spring多配置文件(struts+hibernate+spring)

    这是一个struts+hibernate+spring得完成实例,大部分ssh实例都是在一个配置文件里进行hibernate+spring+struts的配置。我这个很清楚的分成了四个配置文件。非常适合大型项目的开发学习!

    struts+spring+hibernate(mysql)用户登录及文件上传

    Struts配置文件(struts.xml)定义了各个Action和结果页面的映射,使得系统能够根据用户操作跳转到相应的视图。 其次,Spring框架作为整个应用的“胶水”,提供了依赖注入(DI)和面向切面编程(AOP)等功能。在本...

    spring+struts+hibernate实现文件的上传和下载

    - `applicationContext.xml`:Spring 配置文件,配置了数据库连接、事务管理器、以及对 Hibernate SessionFactory 的配置。 - `struts-config.xml`:Struts 配置文件,定义了 Action 和 ActionForm 的映射。 **开发...

    SSH整合源码(Struts+Spring+Hibernate整合用户注册例子)

    7. **整合过程**:SSH整合主要包括配置Struts的配置文件(struts-config.xml),Spring的配置文件(spring-beans.xml),以及Hibernate的配置文件(hibernate.cfg.xml)。Struts和Spring之间通过ActionServlet和Spring的...

    struts2 spring hibernate整合的简单登录代码

    在“struts2springhibernate”这个项目中,我们首先会看到Struts2的配置文件(如struts.xml),它是整个应用的控制器配置,定义了Action类与URL的映射以及结果的跳转。Struts2通过拦截器来处理请求,并利用...

    Struts Spring Hibernate整合实践.doc

    自定义的显示所有用户信息的标签,需要编写一个自定义标签库(Tag Library),并在Struts的配置文件中声明这个标签。标签的实现类需要继承自Struts2的标签基类,并调用Spring服务层的方法获取所有用户数据,然后在...

    struts spring hibernate ssh 三大框架集成详细步骤 手把手教你搭框架

    它通过配置文件将Java类与数据库表进行映射,简化了SQL的编写。在SSH中,Hibernate负责数据持久化,Spring通过SessionFactory获取Session,进而进行CRUD(创建、读取、更新、删除)操作。 **SSH框架集成详细步骤**...

    struts spring hibernate 整合

    2. **配置Spring**:创建Spring的配置文件(如applicationContext.xml),定义Bean,包括DAO、Service以及Struts的Action等,并启用Spring的AOP支持。 3. **配置Struts**:在struts-config.xml中配置Action,同时...

    struts spring hibernate的教学案例项目

    2. **配置文件**:struts-config.xml用于Struts的配置,web.xml是Web应用的部署描述符,applicationContext.xml是Spring的配置,hibernate.cfg.xml是Hibernate的主配置文件。 3. **数据库脚本**:创建数据库和表的...

    Spring,hibernate,struts jar 最新jar包

    Hibernate支持多种数据库,如MySQL、Oracle等,通过配置文件可以轻松切换数据库。它提供了一种映射机制,将Java类和数据库表关联,实现了数据的持久化。Hibernate支持CRUD(Create、Read、Update、Delete)操作,...

Global site tag (gtag.js) - Google Analytics