SSH整合

最新推荐文章于 2024-10-05 11:27:00 发布
最新推荐文章于 2024-10-05 11:27:00 发布
阅读量376 收藏
点赞数
分类专栏： java hibernate 3.3.2 文章标签： ssh spring string list session class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhl324/article/details/7548591
版权 
<?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">
	
	<!-- 1 属性文件加载 指定spring容器要加载的属性文件 用来连接数据库的  -->
	<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<!-- 加载位于src目录下的 jdbc.properties -->
		<property name="location">
        	<value>classpath:/jdbc.properties</value>
    	</property>
		
		<!-- 加载位于webapp目录下的文件  
		<property name="locations">
			<list>
				<value>/WEB-INF/db/jdbc.properties</value>
			</list>
		</property>
		-->
	</bean>
	
	
	<!-- 2 把类交给spring管理 扫描加注解的方式 包及其子包-->
	<context:component-scan base-package="com.scottwong"/>
	
	<!-- 3 配置c3p0数据源-->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
	
		<property name="driverClass" value="${jdbc.driver}"/>
		<property name="jdbcUrl" value="${jdbc.url}"/>
		<property name="user" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"/>
		<!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->
		<property name="initialPoolSize" value="1" />
		<!--连接池中保留的最小连接数。-->
		<property name="minPoolSize" value="1" />
		<!--连接池中保留的最大连接数。Default: 15 -->
		<property name="maxPoolSize" value="300" />
		<!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->
		<property name="maxIdleTime" value="60" />
		<!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
		<property name="acquireIncrement" value="5" />
		<!--每60秒检查所有连接池中的空闲连接。Default: 0 -->
		<property name="idleConnectionTestPeriod" value="60" />
	</bean>
	
	<!-- 4 把SessionFactory交给spring管理 单例 spring和hibernate集成-->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
		<property name="dataSource" ref="dataSource"/>
		<property name="annotatedClasses" ref="annotatedClasses"/>   
		<property name="hibernateProperties">
			 <value>
			      hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
			      hibernate.hbm2ddl.auto=update
			      hibernate.show_sql=false
			      hibernate.format_sql=false
			  </value>
		 </property>
	</bean>
	
	<!-- 5 指定哪些类是和数据库中的表一一对应的。-->  
	<bean	id="annotatedClasses" class="org.springframework.beans.factory.config.ListFactoryBean">   
    	<property name="sourceList">   
	        <list>   
	            <value>com.scottwong.bean.Employee</value>   
	            <value>com.scottwong.bean.Department</value>
	        </list>   
    	</property>   
	</bean>   
	
	<!-- 6 配置spring的事物管理器 把hibernate的事务管理交给spring -->
	<bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"/>
	</bean>
	
	
	<!-- 7 使用基于注解配置事务 -->
	<tx:annotation-driven transaction-manager="txManager"/>
</beans>

 以上是 bean.xml  一共是7步 用的是spring annotation

---------------------------------------------------------------------------------------------------------------------------------------------------

web.xml

 

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_9" version="2.4"
	xmlns="http://java.sun.com/xml/ns/j2ee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

	
	<!-- 指定spring的配置文件，默认从web根目录寻找配置文件，我们可以通过spring提供的classpath:前缀指定从类路径下寻找 -->
	<context-param>
	   <param-name>contextConfigLocation</param-name>
	   <param-value>classpath:beans.xml</param-value>
	</context-param>
	

	<!-- 对Spring容器进行实例化 -->
	<listener>
	      <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	
	<context-param> 
		<param-name>webAppRootKey</param-name> 
		<param-value>webName.root</param-value> 
	</context-param>
	
	<!--由Sprng载入的Log4j配置文件位置-->   
	<context-param>   
	       <param-name>log4jConfigLocation</param-name>   
	       <param-value>classpath:log4j.properties</param-value>   
	</context-param>   
	  
	<!--Spring默认刷新Log4j配置文件的间隔,单位为millisecond-->   
	<context-param>   
	       <param-name>log4jRefreshInterval</param-name>   
	       <param-value>60000</param-value>   
	</context-param>   
	  
	<!--Spring log4j Config loader-->   
	<listener>   
	       <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>   
	</listener>  
	

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

  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>


jdbc.properties

jdbc.username=root
jdbc.password=qq123456
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc\:mysql\://127.0.0.1\:3306/ssh2?useUnicode\=true&characterEncoding\=UTF-8&zeroDateTimeBehavior\=convertToNull
jdbc.dialect=org.hibernate.dialect.MySQLDialect
jdbc.show_sql=true


 

log4j.properties

### 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=info, 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



 

package com.scottwong.action;

import java.util.List;

import javax.annotation.Resource;

import org.springframework.stereotype.Controller;

import com.opensymphony.xwork2.ActionSupport;
import com.scottwong.bean.Employee;
import com.scottwong.service.EmployeeService;
import com.scottwong.util.PageBean;

@Controller
public class EmployeeAction extends ActionSupport {
	@Resource
	private EmployeeService employeeService;
	
	private int page;    //第几页
    private PageBean pageBean;    //包含分布信息的bean
    
    public int getPage() {
        return page;
    }

    public void setPage(int page) {        //若URL中无此参数,会默认为第1页
        this.page = page;
    }

    public PageBean getPageBean() {
        return pageBean;
    }

    public void setPageBean(PageBean pageBean) {
        this.pageBean = pageBean;
    }
	
	
	private List<Employee> listEmployees;    //用来页面显示
	private int id;                          //用来接收参数
	private Employee employee;               //用来页面显示
	
	
	public Employee getEmployee() {
		return employee;
	}

	public void setEmployee(Employee employee) {
		this.employee = employee;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public List<Employee> getListEmployees() {
		return listEmployees;
	}

	public void setListEmployees(List<Employee> listEmployees) {
		this.listEmployees = listEmployees;
	}
	
	/**
	 * http://localhost:8080/ssh2_1.1/employee/employeeAction!add.action
	 */
	public String add(){
//		Employee transientInstance = new Employee("黄家驹",200000,3);
//		employeeService.save(transientInstance);
		return "add";
	}
	
	/**
	 * 显示所有的雇员
	 * http://localhost:8080/ssh2_1.4/employee/employeeAction!list.action
	 */
	public String list(){
		this.pageBean = employeeService.queryForPage(10, page);
		return "list";
	}
	
	
	/**
	 * 显示一个雇员
	 * http://localhost:8080/ssh2_1.1/employee/employeeAction!show.action?id=10
	 */
	public String show(){
		employee = employeeService.findById(id);
		return "show";
	}
	
	
	/**
	 * 修改雇员信息前收集数据
	 * @return
	 */
	public String preUpdate(){
		employee = employeeService.findById(id);
		return "preupdate";
	}
	
	/**
	 * 更新数据
	 * @return
	 */
	public String update(){
		employeeService.update(employee);
		return "update";
	}
	

}


 

package com.scottwong.service;

import java.util.List;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import com.scottwong.bean.Employee;
import com.scottwong.dao.EmployeeDao;
import com.scottwong.dao.PageDao;
import com.scottwong.util.PageBean;

@Service
public class EmployeeService {
	
	@Resource
	private EmployeeDao employeeDao;
	
	@Resource
	private PageDao pageDao;
	
	/** 
     * 分页查询
     * @param currentPage 当前第几页
     * @param pageSize    每页大小
     * @return 封闭了分页信息(包括记录集list)的Bean
     */ 
    public PageBean queryForPage(int pageSize,int page){
        final String hql = "from Employee";        //查询语句
        int allRow = pageDao.getAllRowCount(hql);    //总记录数
        int totalPage = PageBean.countTotalPage(pageSize, allRow);    //总页数
        final int offset = PageBean.countOffset(pageSize, page);    //当前页开始记录
        final int length = pageSize;    //每页记录数
        final int currentPage = PageBean.countCurrentPage(page);
        List list = pageDao.queryForPage(hql,offset, length);        //"一页"的记录
        
        //把分页信息保存到Bean中
        PageBean pageBean = new PageBean();
        pageBean.setPageSize(pageSize);    
        pageBean.setCurrentPage(currentPage);
        pageBean.setAllRow(allRow);
        pageBean.setTotalPage(totalPage);
        pageBean.setList(list);
        pageBean.init();
        return pageBean;
    }
	
	public void save(Employee transientInstance){
		this.employeeDao.save(transientInstance);
	}
	
	public List<Employee> findAllEmployees(){
		return this.employeeDao.findAllEmployees();
	}
	
	public Employee findById(int id) {
		return this.employeeDao.findById(id);
	}
	
	public void update(Employee transientInstance) {
		this.employeeDao.update(transientInstance);
	}
	
	public List<Employee> findAll(){
		return this.employeeDao.findAll();
	}
	public List<Employee> findByHQL(int id,String name){
		return this.employeeDao.findByHQL(id,name);
	}
	public List<Employee> findEmployeesByemployeeName(final String name){
		return this.employeeDao.findEmployeesByemployeeName(name);
	}
	public List<Employee> findByCriteria(int id, String name) {
		return this.employeeDao.findByCriteria(id, name);
	}
	
	public List<Employee> findByDongTaiBangDing(int id, String name) {
		return this.employeeDao.findByDongTaiBangDing(id, name);
	}

}


 

package com.scottwong.dao;

import java.sql.SQLException;
import java.util.List;

import javax.xml.registry.infomodel.User;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.stereotype.Repository;

import com.scottwong.bean.Employee;

@Repository
public class EmployeeDao extends BaseDao {
	private static final Log log = LogFactory.getLog(EmployeeDao.class);

	public void save(Employee transientInstance) {
		log.info("saving Employee instance");
		try {
			getHibernateTemplate().save(transientInstance);
			log.info("save successful");
		} catch (RuntimeException re) {
			log.error("save failed", re);
			throw re;
		}
	}

	public void delete(Employee persistentInstance) {
		log.debug("deleting Employee instance");
		try {
			getHibernateTemplate().delete(persistentInstance);
			log.info("delete successful");
		} catch (RuntimeException re) {
			log.error("delete failed", re);
			throw re;
		}
	}

	public void update(Employee transientInstance) {
		log.info("update Employee instance");
		try {
			getHibernateTemplate().update(transientInstance);
			getHibernateTemplate().flush();
			log.info("update successful");
		} catch (RuntimeException re) {
			log.error("update failed", re);
			throw re;
		}
	}

	@SuppressWarnings("unchecked")
	public List<Employee> findAllEmployees() {
		log.info("finding all Employee instances");
		try {
			String queryString = "from Employee";
			return getHibernateTemplate().find(queryString);
		} catch (RuntimeException re) {
			log.error("find all failed", re);
			throw re;
		}
	}

	public Employee findById(int id) {
		log.info("getting Employee instance with id: " + id);
		try {
			Employee instance = (Employee) getHibernateTemplate().get(
					Employee.class, id);
			return instance;
		} catch (RuntimeException re) {
			log.error("get failed", re);
			throw re;
		}
	}

	public List findByExample(Employee instance) {
		log.debug("finding Employee instance by example");
		try {
			List results = getHibernateTemplate().findByExample(instance);
			log.info("find by example successful, result size: "
					+ results.size());
			return results;
		} catch (RuntimeException re) {
			log.error("find by example failed", re);
			throw re;
		}
	}

	public List findByProperty(String propertyName, Object value) {
		log.info("finding Employee instance with property: " + propertyName
				+ ", value: " + value);
		try {
			String queryString = "from Employee as model where model."
					+ propertyName + "= ?";
			return getHibernateTemplate().find(queryString, value);
		} catch (RuntimeException re) {
			log.error("find by property name failed", re);
			throw re;
		}
	}

	@SuppressWarnings("unchecked")
	public List<Employee> findAll() {
		return (List<Employee>) this.getHibernateTemplate().findByCriteria(
				DetachedCriteria.forClass(Employee.class));

	}

	@SuppressWarnings("unchecked")
	public List<Employee> findByHQL(final int id, final String name) {
		return (List<Employee>) this.getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session) throws HibernateException,SQLException {
						List result = session.createCriteria(Employee.class)
								      .add(Restrictions.ge("employeeId", id)) //ge >= bigger than and equal
								      .add(Restrictions.like("employeeName", "%" + name + "%"))
								      .list();
						return result;
					}
				});

	}
	
	@SuppressWarnings("unchecked")
	public List<Employee> findByCriteria(final int id, final String name) {
		return (List<Employee>) this.getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session) throws HibernateException,SQLException {
						Criteria criteria = session.createCriteria(Employee.class);
						criteria.add(Restrictions.like("employeeName", name+"%")); // Employee有个属性叫name 
						criteria.add(Restrictions.gt("employeeId", id));          // Employee有个属性叫employeeId   
						List<User> list = (List<User>) criteria.list();  
						return list;
					}
				});

	}
	
	/**
	 * 动态绑定参数
	 * @param id
	 * @param name
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public List<Employee> findByDongTaiBangDing(final int id, final String name) {
		return (List<Employee>) this.getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session) throws HibernateException,SQLException {
						String hql ="from Employee as e where e.employeeId >= :id and e.employeeName like :name";
						Query query = session.createQuery(hql);
						query.setInteger("id", id);
						query.setString("name", "%"+name+"%");
						List<User> list = (List<User>) query.list();  
						return list;
					}
				});

	}

	@SuppressWarnings("unchecked")
	public List<Employee> findEmployeesByemployeeName(final String name) {
		return (List<Employee>) this.getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException {
						List<Employee> result = session.createCriteria(
								Employee.class).add(
								Restrictions.like("employeeName", name + "%"))
								.list();
						return result;
					}
				});
	}
}


 

package com.scottwong.dao;

import javax.annotation.Resource;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class BaseDao extends HibernateDaoSupport {

	

	@Resource(name = "sessionFactory") //为父类HibernateDaoSupport注入sessionFactory的值
    public void setSuperSessionFactory(SessionFactory sessionFactory) {
        try{
        	super.setSessionFactory(sessionFactory);
        }catch (Exception e) {
        	e.printStackTrace();
		}
        
    }


}


 

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
	<!-- 默认的视图主题 -->
	<constant name="struts.ui.theme" value="simple"/>
	<constant name="struts.configuration.xml.reload" value="true" />
    <constant name="struts.devMode" value="true" />

	<!-- 使用spring的对象工厂替换struts2默认的对象工厂  由 StrutsSpringObjectFactory 负责Action对象的创建 从spring容器里获取bean实例 -->
	<!-- org.apache.struts2.spring.StrutsSpringObjectFactory -->
	<!-- 配也可以,不配也可以 -->
	<constant name="struts.objectFactory" value="spring" />

	<!-- http://localhost:8080/ssh2/employee/list.action -->
	<package name="employee" namespace="/employee" extends="struts-default">
		<action name="employeeAction" class="employeeAction">
			<result name="add">/employee/add_success.jsp</result>
			<result name="list">/employee/index.jsp</result>
			<result name="preupdate">/employee/pre_update.jsp</result>
			<result name="update" type="redirect" >employeeAction!list.action</result>
		</action>
		
		<action name="listmemberAction" class="listmemberAction">
			<result name="list">/listMember.jsp</result>
		</action>

	</package>
	
	<package name="login" namespace="/login" extends="struts-default">
		<action name="loginAction" class="loginAction">
		</action>

	</package>
</struts>


hhl324
关注
专栏目录
SSH 整合Swagger2
kelly921011的博客
03-19 1003
之前用的是springboot整合swagger2,新公司这边的系统是之前开发的，用的是SSH框架，这里记录一下 整合过程，以及遇到的坑。 1.导入依赖 <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger2 --> <dependency> <groupId>io.springfox</groupId>
ssh整合
没啥简介
07-04 5238
ssh整合 环境 struts2+spring4+hibernate4 jdk1.7 myeclipse 一、导包 1.struts2中的包 struts-2.3.30\apps\struts2-blank\WEB-INF的lib中的全部； struts-2.3.30\lib中的： aopalliance-1.0.jar struts2-spring-plu
ssh整合案例
杨校的博客
04-08 811
Struts2的导入jar包如下： Spring4.2.4的导入jar包如下： HIbernate 5.0.7 的导入jar包如下： MySQL数据库 驱动jar包：
ssh 整合ajax,基于整合ssh ajax案例.doc
weixin_42494628的博客
08-06 230
SSH+Ajax整合????数据库建好我们来搭建SSH框架吧！ ????1.首先创建web工程 ????2.在工程中添加SSH支持 ????SSH的添加顺序和他们的(SSH=Struts+Spring+Hibernate)缩写名字顺序是一致的，不知道起名字的时候是不是按照他们的引入顺序起的。注意：SSH支持引入的时候必须是这个顺序，否则里面会出现很多错误。解决起来很麻烦。尤其是spring的部分。...
SSH的整合
m0_58525944的博客
10-26 1142
ssh 为 struts+spring+hibernate的一个集成框架，是一种Web应用程序开源框架。 一、SSH整合的思路步骤 web+spring+struts+hibernate+杂鱼（杂鱼：比如缓存echache框架、日志框架、tomcat等等） 思路步骤： 1、导入所需要的pom依赖 2、几大框架的配置文件（web.xml/struts.xml、hibernate的配置、spring的配置） 3、spring与hibernate整合 4、spring跟struts整合 5、.
SSH整合实例
Radom&7
08-25 645
这是很久以前学习SSH的一个整合例子，现在整理一下，以便于以后学习。关于SSH框架的整合步骤可以查看我的另外一篇文章《SSH框架搭建》：http://blog.csdn.net/qq_26641781/article/details/76612765整个项目目录： conf文件夹为SSH框架的配置信息db.properties是对数据库信息的配置：user=root password= drive
java ssh 整合_Java - 框架之 SSH 整合
weixin_35943736的博客
02-21 112
十四. ssh 整合1 - 包1. Struts jar 包- Struts-2.xx\apps\stutrs2-blank\WEB-INF\lib2. Hibernate jar 包- hibernate-release-5.0.7.Final\lib\required- mysql 驱动包- 日志记录3. Spring jar 包十五. ssh 整合 - 配置文件1. Struts 配置文件-...
SSH整合导包
hou973561160的博客
09-19 445
一、ssh的图形化记忆运作流程 二、Struts2、hibernate、spring需要引用的jar包 Struts2： 　　基本开发：struts-2.3.32\apps\struts2-blank.war解压后的全部jar, 　　注解开发：struts2-spring-plugin-2.3.32.jar 　　spring整合：struts2-spr
Spring(四)SSH整合
最白の白菜的博客
04-03 213
SSH整合jar包下载地址 SSH整合方式一：无障碍整合 SSH框架整合开发回顾 SSH整合 第一步：创建web项目，引入jar包 Struts2的jar包 struts-2.3.24\apps\struts2-blank\WEB-INF\lib\*.jar Struts2中有一些包需要了解的： struts2-convention-plugin-2.3.24.jar ----Str...
SSH整合Jar包
04-09
SSH整合在JavaWeb开发中是一项重要的技术组合，它包含了三个主要的开源框架：Spring、Struts和Hibernate。这些框架分别负责应用的业务逻辑管理、视图层控制和数据持久化。接下来，我们将深入探讨SSH整合的关键知识点...
SSH整合jar包
06-04
SSH整合jar包是一个集合了所有在Java开发中用于Spring、Struts和Hibernate（SSH）集成应用所需的库文件的压缩包。SSH是Java企业级开发中非常流行的一种框架组合，它能够帮助开发者快速构建高效、可维护的企业级Web...
ssh整合所需所有架包
11-16
SSH整合是Java开发中一种常见的框架集成方式，它结合了Struts2、Spring和Hibernate三个开源框架，以实现高效、灵活的企业级应用开发。这里提到的"ssh整合所需所有架包"是一个包含这三个框架相应版本的集合，确保它们...
ssh整合所需要的jar包
03-21
SSH整合，全称为Struts2、Spring和Hibernate的整合，是Java Web开发中常见的技术栈。这三种框架分别负责表现层、业务层和持久层的管理，通过合理的整合，可以构建出高效、灵活且易于维护的Web应用。下面将详细介绍...
RabbitTemplate与AmqpTemplate：Spring AMQP中的消息传递模板
最新发布
qq_51321722的博客
10-05 392
是Spring AMQP框架的核心接口，它定义了一套标准的AMQP操作，如发送和接收消息、声明队列和交换机等。这个接口是对AMQP协议的抽象，提供了一种面向对象的方式来操作AMQP协议。它基于RabbitMQ的Java客户端库实现，使得开发者可以通过Spring框架的依赖注入和配置机制来简化与AMQP消息队列系统的交互。而则是Spring AMQP为RabbitMQ提供的一个高级消息操作模板。它实现了接口，并添加了一些针对RabbitMQ的特性和优化。不仅提供了与。
netty之SpringBoot+Netty+Elasticsearch收集日志信息数据存储
CSDN_LiMingfly的博客
10-04 465
将大量的业务以及用户行为数据存储起来用于分析处理，但是由于数据量较大且需要具备可分析功能所以将数据存储到文件系统更为合理。尤其是一些互联网高并发级应用，往往数据库都采用分库分表设计，那么将这些分散的数据通过binlog汇总到一个统一的文件系统就显得非常有必要。#开发环境环境准备windows安装包 下载注意 es是以来java环境 所以需要安装jdk 支持1.7以上es-hander下载可视化操作插件@Id//姓名//年龄//级别//时间//电话//邮箱//地址。
SpringBoot--为什么Controller是串行的？怎样才能并行？
IT利刃出鞘的博客
09-29 739
本文介绍SpringBoot为什么Controller是串行的？在什么场景下才能并行执行？
基于SpringBoot原创歌曲分享平台设计与实现
zhshx19900318的博客
09-29 865
在这样的背景下人类社会进入了全新的信息化的时代。在音乐分享管理页面中可以查看索引,音乐分类，音乐名称，音乐视频，区域，视频封面，发布时间，歌词，用户账号，用户姓名等内容，并进行详情，修改，查看评论和删除操作；在举报管理页面中可以查看索引,音乐名称，发布时间，用户账号，用户姓名，举报原因，审核回复，审核状态，审核等内容，并进行详情，修改，删除操作；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值