folwind
folwind

S2SH框架搭建—基于注解配置

此次搭建s2sh框架为本人练手之用，如有不足请见谅，但希望能帮助到大家！

框架采用struts2.3.34、spring4.3.14、hibernate5.1.12版本搭建，jdk版本采用1.6。

框架中一些固定配置不需要长改动，此部分直接配置到xml中，其他配置则使用注解。

1、 S2SH框架介绍

Struts：控制层，用来控制的。
Spring：对Struts和Hibernate进行管理，整合的。
Hibernate：操控数据库，持久化操作。

框架优点：
1.spring管理对象的实例化，把对象的创建和获取放到外部，更加的灵活方便。
2.Hibernate避免了JDBC连接数据库的冗余繁杂。
3.各层分工明细，实现了各层之间的解耦，代码更加灵活

2、 框架依赖包下载

1） Spring

下载地址：https://repo.spring.io/webapp/#/artifacts/browse/tree/General/libs-release-local/org/springframework/spring/4.3.14.RELEASE/spring-framework-4.3.14.RELEASE-dist.zip

S2SH框架搭建—基于注解配置_第1张图片

Spring版本所需JDK支持：

Spring Framework 3.x

JDK5+

Spring Framework 4.x

JDK6+

Spring Framework 5.x

JDK8+

2） struts2

下载地址：http://struts.apache.org/download.cgi

S2SH框架搭建—基于注解配置_第2张图片

Struts2版本所需JDK支持：

Struts2.3.x及以下

JDK5+

Struts2.5.x

JDK7+

 

3） hibernate

下载地址：http://hibernate.org/orm/releases/5.1/

S2SH框架搭建—基于注解配置_第3张图片

Hibernate版本所需JDK支持：

Hibernate 5.0

JDK 6+

Hibernate 5.1

JDK 6+

Hibernate 5.2

JDK 8+

Hibernate 5.3

JDK 8+

 4）其他所需jar可自行搜索下载

3、 项目总体结构

S2SH框架搭建—基于注解配置_第4张图片

4、 导入框架所需jar包

S2SH框架搭建—基于注解配置_第5张图片

5、 配置文件

1） web.xml，其中主要配置spring的listener、struts2的filter，用于启动加载spring、struts2.



	ssh-xml
  	
	
		contextConfigLocation
		classpath:applicationContext.xml
	
	
	
	
		org.springframework.web.context.ContextLoaderListener
	
	
	
	
		org.springframework.web.context.request.RequestContextListener
	

	
	
		org.springframework.web.util.IntrospectorCleanupListener
	
	
	
	
		encodingFilter
		org.springframework.web.filter.CharacterEncodingFilter
		
			encoding
			UTF-8
		
	
	
		encodingFilter
		*.jsp
	

	
		encodingFilter
		*.do
	
	
	
	
	
		openSessionInView
		org.springframework.orm.hibernate5.support.OpenSessionInViewFilter
		
			sessionFactoryBeanName
			sessionFactory
		
		
			singleSession
			true
		
		   
           flushMode   
           AUTO     
        
	

	
		openSessionInView
		*.do
	
	
	   
      
        struts2  
        org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter  
      
  
      
        struts2  
        /*  
    
	
	
		index.html
		index.htm
		index.jsp
		default.html
		default.htm
		default.jsp

2） 属性文件jdbc.properties，配置数据源的相关信息。

### HIBERNATE CONFIG
hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
hibernate.format_sql=false
hibernate.show_sql=false
hibernate.fetch_size=20
hibernate.batch_size=10
hibernate.hbm2ddl=none

### C3P0 CONFIG(NOT BE USED)
jdbc.username=root
jdbc.password=root
jdbc.url=jdbc:mysql://localhost:3306/sshdemo?useUnicode=true&characterEncoding=utf-8&useSSL=false
jdbc.driver=com.mysql.jdbc.Driver
checkoutTimeout=30000
idleConnectionTestPeriod=60
initialPoolSize=5
maxIdleTime=10
maxPoolSize=20
minPoolSize=2
maxStatements=0
maxStatementsPerConnection=0

3） spring配置文件applicationContext.xml



    					
	
	
	
    
    
    
	
		
			
				classpath:jdbc.properties
			
		
	

    
	
        
		
		
		
		
		
		
		
		
		
		
		
    
    
	
	
		
		
			
				${hibernate.dialect}
				${hibernate.format_sql}
				${hibernate.show_sql}
			    ${hibernate.fetch_size}
			    ${hibernate.batch_size}
                ${hibernate.hbm2ddl}
                false  
			
		
		
        
            
                com.folwind.**.entity

4） struts2配置文件struts.xml




	
	
	
	
	
	
	
	
	
	
	
	
    
    
	
	
    
    
    
    
	
	
	

	
	

	
	
	
	
	
	
    
    
    
    
    
     
	
	
	
	
	
	
	
	
	
	 
	
	

    

	
		
		
		
			
				
				
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                     1000
                
                
                
                    input,back,cancel,browse
                
                
                    input,back,cancel,browse
                
                
                
			
		

		

		
		
		    
				
				
		        json
		        
		        
				
				
				
				
				true
				  
                
				
				
		    
			/index.jsp
			/framework/common/exception.jsp

5） 日志配置log4j.properties，配置日志打印的相关信息

#日志框架
#日志等级
#TRACE：详细等级，堆栈信息
#debug：类似于System.out.print
#info：类似于Hibernate的show_sql
#warn：不影响运行， 只是提示
#error：出现异常
#全局日志等级配置,输出位置

log4j.rootLogger=info,stdout,R

#stdout控制器
#org.apache.log4j.ConsoleAppender（控制台），
#org.apache.log4j.FileAppender（文件），
#org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件），
#org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件），
#org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）
#org.apache.log4j.net.SMTPAppender(邮件发送日志)
#org.apache.log4j.jdbc.JDBCAppender  输出到数据库
log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.Target=System.out

#org.apache.log4j.HTMLLayout（以HTML表格形式布局），
#org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
#org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
#org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

#输出格式
# %c  列出logger名字空间的全称，如果加上{<层数>}表示列出从最内层算起的指定层数的名字空间
#                   假设当前logger名字空间是"a.b.c"
#                   %c           a.b.c
#                   %c{2} 	     b.c
#                   %20c 	      （若名字空间长度小于20，则左边用空格填充）
#                   %-20c 	      （若名字空间长度小于20，则右边用空格填充）
#                   %.30c 	      （若名字空间长度超过30，截去多余字符）
#                   %20.30c 	（若名字空间长度小于20，则左边用空格填充；若名字空间长度超过30，截去多余字符）
#                   %-20.30c 	（若名字空间长度小于20，则右边用空格填充；若名字空间长度超过30，截去多余字符）
# %C  列出调用logger的类的全名（包含包路径）
#                   假设当前类是"org.apache.xyz.SomeClass"
#                   %C           org.apache.xyz.SomeClass
#                   %C{1} 	     SomeClass
# %d  显示日志记录时间，{<日期格式>}使用ISO8601定义的日期格式 	
#                   %d{yyyy/MM/dd HH:mm:ss,SSS} 	   2005/10/12 22:23:30,117
#                   %d{ABSOLUTE} 	                   22:23:30,117
#                   %d{DATE} 	                       12 Oct 2005 22:23:30,117
#                   %d{ISO8601} 	                   2005-10-12 22:23:30,117
# %F  显示调用logger的源文件名 	
#                   %F 	         MyClass.java
# %l  输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数
#                   %l           MyClass.main(MyClass.java:129)
# %L  显示调用logger的代码行 
#                   %L           129
# %m  显示输出消息
#                   %m           This is a message for debug.
# %M  显示调用logger的方法名 
#                   %M           main
# %n  当前平台下的换行符 
#                   %n           Windows平台下表示rn，UNIX平台下表示n
# %p  显示该条日志的优先级
#                   %p           INFO
# %r  显示从程序启动时到记录该条日志时已经经过的毫秒数
#                   %r           1215
# %t  输出产生该日志事件的线程名
#                   %t           MyClass
# %x  按NDC（Nested Diagnostic Context，线程堆栈）顺序输出日志
#                   假设某程序调用顺序是MyApp调用com.foo.Bar
#                   %c %x - %m%n               MyApp - Call com.foo.Bar. 
#                                              com.foo.Bar - Log in Bar
#                                              MyApp - Return to MyApp.
# %X  按MDC（Mapped Diagnostic Context，线程映射表）输出日志。通常用于多个客户端连接同一台服务器，方便服务器区分是那个客户端访问留下来的日志。
#                   %X{5} 	（记录代号为5的客户端的日志）
# %%  显示一个百分号
#                   %%           %
log4j.appender.stdout.layout.ConversionPattern= [%p] %d{yyyy-MM-dd HH:mm:ss,SSS} [%c.%M(%F:%L)] --> %m%n
#log4j.appender.stdout.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

#文件路径输出
log4j.appender.R=org.apache.log4j.RollingFileAppender
#默认输出到tomcat的根路径或者运行测试工程的根路径
log4j.appender.R.File=D\:/work/workspaces/training-workspaces/apache-tomcat-6.0.37/logs/ssh-scan.log
log4j.appender.D.Append = true
#log4j.appender.D.Threshold = error
log4j.appender.R.MaxFileSize=1024KB
# Keep three backup files.
log4j.appender.R.MaxBackupIndex=20
# Pattern to output: date priority [category] - message
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern= [%p] %d{yyyy-MM-dd HH:mm:ss,SSS} [%c.%M(%F:%L)] --> %m%n

6、 Base组件定义，定义分页组件PageModel、BaseDAO持久化操作、BaseService基本业务逻辑操作、BaseActionSupport控制层

1） 分页组件PageModel

package com.folwind.framework.core;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class PageModel {
	// 总记录数
	private int totalRecords = 0;
	// 结果集
	private List data = Collections.emptyList();
	// 当前页
	private int pageNo = 1;
	// 每页显示多少条
	private int pageSize = 10;
	
	private List sortField = null;
	
	private List directions = null;
	
	private boolean success = true;
	
	private String msg = "";
	
	private final String SPACE = " ";
	
	public int getTotalRecords() {
		return totalRecords;
	}

	public void setTotalRecords(int totalRecords) {
		this.totalRecords = totalRecords;
	}

	public List getData() {
		return data;
	}

	public void setData(List data) {
		this.data = data;
	}

	public int getPageSize() {
		return pageSize;
	}

	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}

	public int getPageNo() {
		return pageNo;
	}

	public void setPageNo(int pageNo) {
		this.pageNo = pageNo;
	}

	public boolean isNull() {
		if (data == null || data.size() <= 0) {
			return true;
		} else {
			return false;
		}
	}
	
	public void addSort(String fieldName, String direction) {
		if(this.sortField == null) {
			this.sortField = new ArrayList(1);
			this.directions = new ArrayList(1);
		}
		this.sortField.add(fieldName);
		this.directions.add(direction);
	}
	
	public String generateSortStr() {
		StringBuilder builder = new StringBuilder();
		if(this.sortField != null) {
			int length = this.sortField.size();
			for (int i = 0; i < length; i++) {
				if( i > 0) {
					builder.append(", ");
				}
				builder.append(this.sortField.get(i));
				builder.append(SPACE);
				builder.append(this.directions.get(i));
			}
		}
		return builder.toString();
	}
	
	public boolean isSuccess() {
		return success;
	}

	public void setSuccess(boolean success) {
		this.success = success;
	}

	public String getMsg() {
		return msg;
	}

	public void setMsg(String msg) {
		this.msg = msg;
	}
}

2） BaseDAO

package com.folwind.framework.core;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.hibernate.transform.Transformers;
import org.springframework.orm.hibernate5.HibernateCallback;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import org.springframework.stereotype.Repository;

import com.folwind.framework.util.HqlConvertUtil;
import com.folwind.framework.util.PageUtil;

@SuppressWarnings("unchecked")
@Repository
public class BaseDAO extends HibernateDaoSupport {
	
	public T load(Class clazz, Serializable id) {
		return this.getHibernateTemplate().load(clazz, id);
	}
	
	public void save(T obj) throws Exception {
		getHibernateTemplate().save(obj);
		getHibernateTemplate().flush();
	}
	
	public void update(T obj) throws Exception {
		getHibernateTemplate().update(obj);
		getHibernateTemplate().flush();
	}
	
	public void saveOrUpdate(T obj) throws Exception {
		getHibernateTemplate().saveOrUpdate(obj);
		getHibernateTemplate().flush();
	}
	
	public void merge(T obj) throws Exception {
		getHibernateTemplate().merge(obj);
		getHibernateTemplate().flush();
	}
	
	public void delete(T obj) throws Exception {
		if(obj != null) {
			getHibernateTemplate().delete(obj);
			getHibernateTemplate().flush();
		}
	}
	
	public void delete(Class clazz, Serializable id) throws Exception {
		T obj = load(clazz, id);
		if (obj != null)
			delete(obj);
	}
	
	public void delete(String hql) throws Exception {
		this.getHibernateTemplate().deleteAll(find(hql));
	}
	
	public void delete(String hql, String paramName, Object value) throws Exception {
		this.getHibernateTemplate().deleteAll(find(hql, paramName, value));
	}
	
	public void delete(String hql, List paramNames, List values) throws Exception {
		this.getHibernateTemplate().deleteAll(find(hql, paramNames, values));
	}
	
	public List findAll(Class clazz) throws Exception {
		return this.getHibernateTemplate().loadAll(clazz);
	}
	
	public List find(String hql) throws Exception {
		return (List) getHibernateTemplate().find(HqlConvertUtil.convert(hql));
	}
	
	public List find(String hql, String paramName, Object value) throws Exception {
		return (List) getHibernateTemplate().findByNamedParam(HqlConvertUtil.convert(hql), paramName, value);
	}
	
	public List find(String hql, List paramNames, List values) throws Exception {
		return (List) getHibernateTemplate().findByNamedParam(HqlConvertUtil.convert(hql), paramNames.toArray(new String[paramNames.size()]), values.toArray());
	}
	
	/**
	 * 根据属性名和属性值查询对象 ，返回唯一对象
	 */
	public T findBy(Class clazz, String paramName, Object value) throws Exception {
		Criteria criteria = currentSession().createCriteria(clazz);
		criteria.add(Restrictions.eq(paramName, value));
		return (T) criteria.uniqueResult();
	}
	
	/**
	 * 根据属性名和属性值查询对象 ，返回符合条件的对象列表
	 */
	public List findAllBy(Class clazz, String paramName, Object value) throws Exception {
		Criteria criteria = currentSession().createCriteria(clazz);
		criteria.add(Restrictions.eq(paramName, value));
		return criteria.list();
	}
	
	/**
	 * 根据属性名和属性值查询对象 ，返回符合条件的排序对象列表
	 */
	public List findAllBy(Class clazz, String paramName, Object value, String orderby) throws Exception {
		Criteria criteria = currentSession().createCriteria(clazz);
		criteria.add(Restrictions.eq(paramName, value));
		criteria.addOrder(Order.asc(orderby));
		return criteria.list();
	}
	
	public List findAllBy(Class clazz, String paramName, Object value, String orderby, boolean asc) throws Exception {
		Criteria criteria = currentSession().createCriteria(clazz);
		criteria.add(Restrictions.eq(paramName, value));
		if (asc)
			criteria.addOrder(Order.asc(orderby));
		else
			criteria.addOrder(Order.desc(orderby));
		return criteria.list();
	}
	
	/**
	 * 根据属性名和属性值查询对象 ，返回符合条件的对象列表
	 */
	public List findAllByLike(Class clazz, String name, Object value) throws Exception {
		Criteria criteria = currentSession().createCriteria(clazz);
		criteria.add(Restrictions.like(name, value));
		return criteria.list();
	}
	
	/**
	 * -----------------------------------------------------------------------
	 * 搜索统一实现
	 * -----------------------------------------------------------------------
	 */
	public PageModel findPage(String hql, PageModel pm) throws Exception {
		return findPage(hql, null, null, pm);
	}
	
	/**
	 * 根据HQL语句进行分页查询
	 * 
	 * @param hql HQL语句
	 * @param params HQL语句带的多个参数值
	 * @param offset 从第几条记录开始查询
	 * @param pageSize 每页显示多少行
	 * @return 分页模型
	 */
	public PageModel findPage(final String hql, final List paramNames, final List values, PageModel pm) throws Exception {
		// 获取总记录数total
		if(paramNames != null && values != null && paramNames.size() != values.size()) {
			throw new Exception("参数列表不一致！");
		}
		final String convertedHql = HqlConvertUtil.convert(hql);
		final String countHql = getCountHql(convertedHql);
		
	
		int total = (Integer)getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session session) throws HibernateException {
				
				Query query = session.createQuery(countHql);
				setParameters(query, paramNames, values);
				return ((Long) query.uniqueResult()).intValue();
			}
	    });
		
		final int pageNo = pm.getPageNo();
		final int pageSize = pm.getPageSize();
		List datas = (List)getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session session) throws HibernateException {
				
				Query query = session.createQuery(convertedHql);
				setParameters(query, paramNames, values);
				return query.setFirstResult((pageNo - 1) * pageSize).setMaxResults(pageSize).list();
			}
	    });

	    int pageCurrent = PageUtil.getCurrentPage(total, pm.getPageSize(), pm.getPageNo());
	    
	    pm.setPageNo(pageCurrent);
		// 返回数据
		pm.setTotalRecords(total);
		pm.setData(datas);
		return pm;
	}
	
	public int executeSql(String sql) throws Exception {
		Query query = currentSession().createSQLQuery(sql);
		return query.executeUpdate();
	}
	
	public List> findBySql(String sql) throws Exception {
		Query query = currentSession().createSQLQuery(sql);
		query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
		return query.list();
	}

	public List> findBySql(String sql, String paramName, Object value) throws Exception {
		Query query = currentSession().createSQLQuery(sql);
		query.setParameter(paramName, value);
		query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
		return query.list();
	}
	
	public List> findBySql(String sql, List paramNames, List values) throws Exception {
		Query query = currentSession().createSQLQuery(sql);
		setParameters(query, paramNames, values);
		query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
		return query.list();
	}
	
	public PageModel findPageBySql(String sql, String countSql, PageModel pm) throws Exception {
		Query countquery = currentSession().createSQLQuery(countSql);
		List countList = countquery.list();
		int rowCount = 0;
		if ((countList != null) && (!countList.isEmpty())) {
			rowCount = new Integer(countList.get(0).toString()).intValue();
		}
	    int pageCurrent = PageUtil.getCurrentPage(rowCount, pm.getPageSize(), pm.getPageNo());
	    
	    pm.setTotalRecords(rowCount);
	    pm.setPageNo(pageCurrent);
		
		Query query = currentSession().createSQLQuery(sql);
		query.setFirstResult((pageCurrent - 1) * pm.getPageSize());
	    query.setMaxResults(pm.getPageSize());
		query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
		
		pm.setData(query.list());
		
		return pm;
	}
	
	public PageModel findPageBySql(String sql, String countSql, String paramName, Object value, PageModel pm) throws Exception {
		Query countquery = currentSession().createSQLQuery(countSql);
		countquery.setParameter(paramName, value);
		List countList = countquery.list();
		int rowCount = 0;
		if ((countList != null) && (!countList.isEmpty())) {
			rowCount = new Integer(countList.get(0).toString()).intValue();
		}
	    int pageCurrent = PageUtil.getCurrentPage(rowCount, pm.getPageSize(), pm.getPageNo());
	    
	    pm.setTotalRecords(rowCount);
	    pm.setPageNo(pageCurrent);
		
		Query query = currentSession().createSQLQuery(sql);
		query.setParameter(paramName, value);
		query.setFirstResult((pageCurrent - 1) * pm.getPageSize());
	    query.setMaxResults(pm.getPageSize());
		query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
		
		pm.setData(query.list());
		
		return pm;
	}
	
	public PageModel findPageBySql(String sql, String countSql, List paramNames, List values, PageModel pm) throws Exception {
		Query countquery = currentSession().createSQLQuery(countSql);
		setParameters(countquery, paramNames, values);
		List countList = countquery.list();
		int rowCount = 0;
		if ((countList != null) && (!countList.isEmpty())) {
			rowCount = new Integer(countList.get(0).toString()).intValue();
		}
	    int pageCurrent = PageUtil.getCurrentPage(rowCount, pm.getPageSize(), pm.getPageNo());
	    
	    pm.setTotalRecords(rowCount);
	    pm.setPageNo(pageCurrent);
		
		Query query = currentSession().createSQLQuery(sql);
		setParameters(query, paramNames, values);
		query.setFirstResult((pageCurrent - 1) * pm.getPageSize());
	    query.setMaxResults(pm.getPageSize());
		query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
		
		pm.setData(query.list());
		
		return pm;
	}
	
	/**
	 * 根据HQL语句，获得查找总记录数的HQL语句 如： select ... from Orgnization o where o.parent is
	 * null 经过转换，可以得到： select count(*) from Orgnization o where o.parent is null
	 * @param hql
	 * @return 
	 */
	private String getCountHql(String hql) throws Exception {
		int index = hql.indexOf("from");
		if (index != -1) {
			return "select count(*) " + hql.substring(index);
		}
		return null;
	}
	
	private void setParameters(Query query, List paramNames, List values) throws HibernateException {
		if (paramNames != null && paramNames.size() > 0) {
			int length = paramNames.size();
			Object obj = null;
			for (int i = 0; i < length; i++) {
				obj = values.get(i);
				if(obj == null) {
					continue;
				}
				if(Collection.class.isAssignableFrom(obj.getClass())) {
					query.setParameterList(paramNames.get(i), (Collection) obj);
				}
				else if(obj.getClass().isArray()) {
					query.setParameterList(paramNames.get(i), (Object[])obj);
				}
				else {
					query.setParameter(paramNames.get(i), values.get(i));
				}
			}
		}
	}
} 
  
3） BaseService
 
  
package com.folwind.framework.core;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;

public abstract class BaseService {
	@Autowired
	protected BaseDAO dao;

	public abstract Class getEntityClass();
	public abstract String getEntityClassName();

	/**
	 * 生成hql的条件语句，开头为and条件连接符,实体别名为t
	 * @param queryEntity 存储查询条件的实体对象
	 * @param paramNames 条件语句中的插值符
	 * @param values  条件语句中插值符的值
	 * @return
	 */
	protected abstract String generateWheres(T queryEntity, List paramNames, List values) throws Exception;

	public T loadById(Serializable id) {
		return dao.load(getEntityClass(), id);
	}

	public void save(T obj) throws Exception {
		dao.save(obj);
	}

	public void update(T obj) throws Exception {
		dao.update(obj);
	}

	public void saveOrUpdate(T obj) throws Exception {
		dao.saveOrUpdate(obj);
	}

	public void merge(T obj) throws Exception {
		dao.merge(obj);
	}

	public void delete(T obj) throws Exception {
		dao.delete(obj);
	}

	public void deleteById(Serializable id) throws Exception {
		dao.delete(getEntityClass(), id);
	}

	public void deleteByIds(Serializable[] ids) throws Exception {
		for (int i = 0; i < ids.length; i++) {
			dao.delete(getEntityClass(), ids[i]);
		}
	}

	public List findAll() throws Exception {
		return dao.findAll(getEntityClass());
	}

	/**
	 * 根据属性名和属性值查询对象 ，返回唯一对象
	 */
	public T findBy(String name, Object value) throws Exception {
		return dao.findBy(getEntityClass(), name, value);
	}

	/**
	 * 根据属性名和属性值查询对象 ，返回符合条件的对象列表
	 */
	public List findAllBy(String name, Object value) throws Exception {
		return dao.findAllBy(getEntityClass(), name, value);
	}

	/**
	 * 根据属性名和属性值查询对象 ，返回符合条件的排序对象列表
	 */
	public List findAllBy(String name, Object value, String orderby) throws Exception {
		return dao.findAllBy(getEntityClass(), name, value, orderby);
	}

	public List findAllBy(String name, Object value, String orderby, boolean asc) throws Exception {
		return dao.findAllBy(getEntityClass(), name, value, orderby, asc);
	}

	/**
	 * 根据属性名和属性值查询对象 ，返回符合条件的对象列表
	 */
	public List findAllByLike(String name, Object value) throws Exception{
		return dao.findAllByLike(getEntityClass(), name, value);
	}

	/**
	 * -----------------------------------------------------------------------
	 * 搜索统一实现
	 * -----------------------------------------------------------------------
	 */
	protected PageModel findPage(String hql, PageModel pm) throws Exception{
		return dao.findPage(hql, pm);
	}

	/**
	 * 根据HQL语句进行分页查询
	 * 
	 * @param hql HQL语句
	 * @param params HQL语句带的多个参数值
	 * @param offset 从第几条记录开始查询
	 * @param pageSize 每页显示多少行
	 * @return 分页模型
	 */
	protected PageModel findPage(String hql, List paramNames, List values, PageModel pm) throws Exception {
		return dao.findPage(hql, paramNames, values, pm);
	}

	public PageModel findPage(T queryEntity, PageModel pm) throws Exception {
		List paramNames = new ArrayList();
		List values = new ArrayList();
		StringBuilder builder = generateHql(generateWheres(queryEntity, paramNames, values), pm.generateSortStr());

		return dao.findPage(builder.toString(), paramNames, values, pm);
	}

	public BaseDAO getDao() {
		return dao;
	}

	public void setDao(BaseDAO dao) {
		this.dao = dao;
	}

	/**
	 * 生成hql语句,实体别名为t
	 * @param wheres 条件语句，开头为and条件连接符
	 * @param orderBy 排序语句，可多个字段排序，例：field1 asc,field2 desc
	 * @return
	 */
	protected StringBuilder generateHql(String wheres, String orderBy) throws Exception {
		StringBuilder builder = new StringBuilder();
		builder.append("from ");
		builder.append(getEntityClassName());
		builder.append(" t ");
		builder.append(" where 1=1 ");
		if(StringUtils.isNotBlank(wheres)) {
			builder.append(wheres);
		}
		if(StringUtils.isNotBlank(orderBy)) {
			builder.append(" order by ");
			builder.append(orderBy);
		}

		return builder;
	}
} 
  
4） BaseActionSupport
 
  
package com.folwind.framework.core;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import net.sf.json.JSONArray;

import org.apache.struts2.interceptor.ServletRequestAware;
import org.apache.struts2.interceptor.ServletResponseAware;
import org.apache.struts2.interceptor.SessionAware;
import org.springframework.beans.factory.annotation.Autowired;

import com.folwind.sys.menu.service.SysMenuService;
import com.folwind.sys.user.service.SysUserService;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.Preparable;

//继承ActionSupport，让本类具备强大的功能（例如：校验、国际化等）
public abstract class BaseActionSupport extends ActionSupport implements SessionAware, ServletRequestAware, ServletResponseAware, Preparable {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	protected final String JSON = "json";

	protected HttpServletResponse response;
	protected HttpServletRequest request;
	protected Map session;

	private Object json;
	private Map jsonMap;

	//=================Service注入========================
	@Autowired
	protected SysUserService sysUserService;
	@Autowired
	protected SysMenuService sysMenuService;

	@Override
	public void prepare() throws Exception {
		this.jsonMap = new HashMap(5);
		setSuccessJson();
	}

	@Override
	public void setServletResponse(HttpServletResponse response) {
		this.response = response;
	}

	@Override
	public void setServletRequest(HttpServletRequest request) {
		this.request = request;
	}

	@Override
	public void setSession(Map session) {
		this.session = session;
	}

	public void setJson(Object json) {
		this.json = json;
	}

	public Object getJson() {
		return this.json;
	}

	protected void setSuccessJson() {
		jsonMap.put("success", Boolean.TRUE);
		jsonMap.put("msg", "操作成功");
		setJson(jsonMap);
	}

	protected void setSuccessJson(String msg) {
		jsonMap.put("success", Boolean.TRUE);
		jsonMap.put("msg", msg);
		setJson(jsonMap);
	}

	protected void addJson(String key, Object value) {
		jsonMap.put(key, value);
		setJson(jsonMap);
	}

	protected void setFailJson(String errorMsg) {
		jsonMap.put("success", Boolean.FALSE);
		jsonMap.put("msg", errorMsg);
		setJson(jsonMap);
	}

	/**
	 * 将list转换成json数据
	 * @param list
	 * @return
	 */
	public String convertListToJson(List list) {
		//将list转为json
		JSONArray jsonArray = new JSONArray();
		jsonArray = JSONArray.fromObject(list);
		return  jsonArray.toString();
	}

	/**
	 * 输出字符串 Json数据
	 * @param json
	 */
	public void outPutJson(String json) {
		try {
			// 设置文本流头信息
			response.setContentType("text/html;charset=UTF-8");
			// 获取流
			PrintWriter out = response.getWriter();
			// 将流打到客户端
			out.print(json);
			// 清空缓存
			out.flush();
			// 关闭流
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}
 
  
7、 Entity，数据库表ORM映射信息
 
  
package com.folwind.sys.user.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;

/**
 * SysUser entity. @author MyEclipse Persistence Tools
 */
@Entity//声明当前类为hibernate映射到数据库中的实体类
@Table(name = "T_SYS_USER")
public class SysUser implements java.io.Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	// Fields

	@Id//声明此列为主键,作为映射对象的标识符
	/**
	 *  @GeneratedValue注解来定义生成策略
	 *  GenerationType.TABLES 当前主键的值单独保存到一个数据库的表中
	 *  GenerationType.SEQUENCE  利用底层数据库提供的序列生成标识符
	 *  GenerationType.IDENTITY 采取数据库的自增策略
	 *  GenerationType.AUTO 根据不同数据库自动选择合适的id生成方案，这里使用mysql,为递增型
	 */
	//@GeneratedValue(strategy = GenerationType.AUTO)
	@GenericGenerator(name = "assigned", strategy = "assigned")
	@GeneratedValue(generator="assigned")
	@Column(name = "ID", unique=true, nullable = false, length=50)
	private String id;

	@Column(name = "PASSWORD", length = 32)
	private String password;

	@Column(name = "REAL_NAME", length = 255)
	private String realName;

	@Column(name = "EMAIL", length = 255)
	private String email;

	@Column(name = "MOBILE", length = 16)
	private String mobile;

	@Column(name = "ORG_ID", length = 50)
	private String orgId;

	// Constructors

	/** default constructor */
	public SysUser() {
	}

	/** minimal constructor */
	public SysUser(String id) {
		this.id = id;
	}

	/** full constructor */
	public SysUser(String id, String password, String realName, String email,
			String mobile, String orgId) {
		this.id = id;
		this.password = password;
		this.realName = realName;
		this.email = email;
		this.mobile = mobile;
		this.orgId = orgId;
	}

	// Property accessors

	public String getId() {
		return this.id;
	}

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

	public String getPassword() {
		return this.password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public String getRealName() {
		return this.realName;
	}

	public void setRealName(String realName) {
		this.realName = realName;
	}

	public String getEmail() {
		return this.email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public String getMobile() {
		return this.mobile;
	}

	public void setMobile(String mobile) {
		this.mobile = mobile;
	}

	public String getOrgId() {
		return this.orgId;
	}

	public void setOrgId(String orgId) {
		this.orgId = orgId;
	}

}
 
  
8、 Service，service层业务逻辑操作，继承BaseService
 
  
package com.folwind.sys.user.service;

import java.util.List;

import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Service;

import com.folwind.framework.core.BaseService;
import com.folwind.sys.user.entity.SysUser;

@Service
public class SysUserService extends BaseService {

	@Override
	public Class getEntityClass() {
		return SysUser.class;
	}

	@Override
	public String getEntityClassName() {
		return "SysUser";
	}

	@Override
	protected String generateWheres(SysUser queryEntity,
			List paramNames, List values) throws Exception {
		if(queryEntity == null) {
			return "";
		}
		StringBuilder sb = new StringBuilder();

		if(StringUtils.isNotBlank(queryEntity.getRealName())) {
			sb.append(" and t.realName like :realName");
			paramNames.add("realName");
			values.add("%" + queryEntity.getRealName() + "%");
		}
		if(StringUtils.isNotBlank(queryEntity.getMobile())) {
			sb.append(" and t.mobile like :mobile");
			paramNames.add("mobile");
			values.add("%" + queryEntity.getMobile() + "%");
		}
		return sb.toString();
	}
} 
  
9、 Action，action层控制逻辑操作，继承BaseActionSupport
 
  
package com.folwind.sys.user.action;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;

import com.folwind.framework.core.BaseActionSupport;
import com.folwind.framework.core.PageModel;
import com.folwind.framework.util.BeanUtil;
import com.folwind.framework.util.PageUtil;
import com.folwind.sys.user.entity.SysUser;

@Results({
	@Result(name="list",location="/sys/user/jsp/user.jsp")
})
public class SysUserAction extends BaseActionSupport {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private final Log LOG = LogFactory.getLog(SysUserAction.class);

	private SysUser entity;
	private String id;

	public String list() {
		return "list";
	}

	public String search() {
		PageModel pm = null;
		try {
			pm = PageUtil.createPageModel(request);

			pm = sysUserService.findPage(getEntity(), pm);

			pm.setSuccess(Boolean.TRUE);
			pm.setMsg("查询数据成功！");
		} catch (Exception e) {
			if(pm == null) {
				pm = new PageModel();
			}

			pm.setSuccess(Boolean.FALSE);
			pm.setMsg("查询数据失败！");
			LOG.error("查询数据失败！" + e.getMessage(), e);
		}
		setJson(pm);

		return JSON;
	}

	public String searchById() {
		try {
			entity = sysUserService.loadById(id);

			addJson("entity", entity);
			setSuccessJson("查询数据成功！");
		} catch (Exception e) {
			setFailJson("查询数据失败！");
			LOG.error("查询数据失败！" + e.getMessage(), e);
		}

		return JSON;
	}

	public String doCreate() {
		try {
			sysUserService.save(getEntity());

			setSuccessJson("创建数据成功！");
		} catch (Exception e) {
			setFailJson("创建数据失败！");
			LOG.error("创建数据失败！" + e.getMessage(), e);
		}

		return JSON;
	}

	public String doModify() {
		try {
			SysUser entity = getEntity();
			SysUser oldEntity = sysUserService.loadById(entity.getId());

			BeanUtil.copyPropertiesExcludeNullValue(oldEntity, entity);

			sysUserService.update(oldEntity);

			setSuccessJson("修改数据成功！");
		} catch (Exception e) {
			setFailJson("修改数据失败！");
			LOG.error("修改数据失败！" + e.getMessage(), e);
		}

		return JSON;
	}

	public String delete() {
		try {
			if(StringUtils.isNotBlank(id)) {
				sysUserService.deleteByIds(StringUtils.split(id.toString(), ","));
			}

			setSuccessJson("删除数据成功！");
		} catch (Exception e) {
			setFailJson("删除数据失败！");
			LOG.error("删除数据失败！" + e.getMessage(), e);
		}

		return JSON;
	}

	public SysUser getEntity() {
		return this.entity;
	}

	public void setEntity(SysUser entity) {
		this.entity = entity;
	}

	public String getId() {
		return id;
	}

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

}
 
  
10、 前台调用
 
  
前台调用Action方法的方式：sys-user!list.do
 
  
S2SH框架搭建—基于注解配置_第6张图片
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(框架学习)

        

            

                
    
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • Dojo-CodeLab: JavaScript与Dojo框架学习与实践指南
                        陈马登Morden

                        
    本文还有配套的精品资源，点击获取简介：Dojo-CodeLab是一个提供学习和实践JavaScript及其Dojo框架的项目，专注于为初学者提供无需特定环境限制的编程平台。通过开发一个简单的计算器应用，学习者将掌握JavaScript基础语法和Dojo工具集的使用，涵盖变量、数据类型、控制结构、函数、对象、数学运算、事件处理和DOM操作等关键概念。本项目通过实际编码练习帮助学习者加深对前端开发的理
    
                    
    • 
                    
  • 集合框架学习题
                        奶糖趣多多
java开发语言
                        
    ArrayList集合存储HashMap元素并遍历importjava.util.ArrayList;importjava.util.HashMap;importjava.util.Set;publicclassArrayListIncludeHashMapDemo{publicstaticvoidmain(String[]args){//创建ArrayList集合ArrayList>array=
    
                    
    • 
                    
  • golang学习笔记——Gin、Beego、Iris、Echo框架学习资料
                        怪我冷i
golang从入门到入门golang
                        
    GinGin文档-中文Gin文档-英文BeegoBeego文档-中文Beego文档-英文应用例子IrisIris文档-中文Iris文档-英文EchoEcho文档-中文Echo文档-英文Echo中间件
    
                    
    • 
                    
  • 学懂C#编程：常用框架学习（三）——.NET Framework框架下的Entity Framework （EF）开发应用详解
                        猿享天开
学懂C#-高级编程技术精讲c#学习.netEFEF框架
                        
    目录一、EntityFramework概述二、EntityFramework的核心组成部分EntityDataModel(EDM)：EntityClient：ObjectServices：ADO.NETProvider：三、分层结构应用程序层：EntityFramework层：数据库层：四、EF主要的功能包括五、三种开发模式详解1.代码优先（CodeFirst）2.数据库优先（DatabaseFi
    
                    
    • 
                    
  • 2022-02-27 Node.js Express框架学习笔记(三) 中间件(Middleware):局部中间件,应用级中间件,路由级中间件,错误处理中间件
                        前端OnTheRun
笔记nodejsexpressjs中间件node.jsexpress路由后端
                        
    文章目录0.Express中间件的概念定义本质调用流程next参数&next()函数中间件的作用中间件的分类注意事项1.局部生效的中间件示例2.应用级中间件(全局)语法示例:把复用性高的路由改成应用级中间件应用级中间件的注册顺序3.路由级中间件语法示例一:应用级中间件和路由级中间件的对比例子示例二:路由中间件只处理单一功能/页面4.错误处理中间件语法示例:处理浏览器地址访问不存在目录的错误0.Ex
    
                    
    • 
                    
  • 第4章 .NET 8.0 ASP.NET Core图书管理系统 ：项目布局
                        代数狂人
ASP.NETCore框架之旅.netasp.net后端ASP.NETCore
                        
    第1章框架学习的基石与实战策略第2章大话ASP.NETCore入门第3章创建最小（MinimalAPIs）API应用程序第4章.NET8.0ASP.NETCore图书管理系统：项目布局</
    
                    
    • 
                    
  • MyBatis框架学习过程中遇到的问题总结
                        爱喝冰红茶阿
Mybatismybatisspringmvc
                        
    问题一：在主配置文件中配置映射文件的时候映射文件名写错产生原因：出现此错误的主要原因是对Mybatis的主配置文件以及XML映射文件之间的配置不熟悉，在初学时，往往会忽略映射文件在主配置文件中的配置。解决方案：解决该问题的方案是要深刻理解并熟悉Mybatis的配置文件与映射文件之间的关系，在Mybatis框架的使用中，尽可能的去避免由于配置产生的错误。问题二：在加载映射文件时Mybatis发现该方
    
                    
    • 
                    
  • WPF Prism框架学习
                        习明然
学习
                        
    这里主要写一些经验总结，综合网上的各种文章和博客，如果是入门请看连接https://www.cnblogs.com/zh7791/p/14102046.html1、Prism.DryIoc和Prism.Unity都可以创建Prism项目，分属于不同的容器。前者关联依赖的dll更少，文件占用更小2、如果有依赖包，请不要根据依赖包支持的最低环境来更新，如需更新请更新关联的所以依赖包3、Prism.Dr
    
                    
    • 
                    
  • Django框架学习入门
                        数字化信息化智能化解决方案
django学习sqlite
                        
    Django是一个开放源代码的高级Web应用框架，由Python语言编写，用于开发Web后端程序。以下是Django框架学习入门的简要指南：环境准备：安装Python：确保你安装了适当版本的Python。Django3.x通常需要Python3.6到3.10之间的版本。虚拟环境：为了保持项目的依赖隔离，建议使用virtualenv或venv创建一个虚拟环境。安装Django：在你的虚拟环境中，通过
    
                    
    • 
                    
  • 基于学习路径分析的小学数学教学：概述与基本框架学习笔记
                        666小飞鱼

                        
    （三）分析学习路径在理解学习目标、确定学习路径之后，下一步可以对学生可能的学习路径进行分析。当然，学生的学习路径应当是多元的，并不存在唯一的标准答案。只要从适合学生的学习起点出发，能真正促进学生的理解，就可以认为是合理的学习路径。而如果没有很好的确定学生的学习起点，在分析学习路径时，就有可能出现一些问题。比如在“三角形的内角和”一课中，有的老师认为学生在经历“量”“拼”“折”这样的合情推理时，并不
    
                    
    • 
                    
  • Django框架学习--4--分布式路由&ORM基础
                        ArliKache
pythonWebdjangopython后端
                        
    本篇文章要点：1.如何通过分布式路由方法避免主路由文件的urlpatterns过于臃肿？2.使用ORM框架代替数据库的操作？1.Django的分布式路由实现创建应用应用在django项目中是一个独立的业务模块，可以包含自己的路由、视图、模版和模型；例如在大型网站中会有音乐、新闻、体育各个频道，这每一个都可以做成一个应用。基本步骤：创建应用文件夹：python3manage.pystartapp应用
    
                    
    • 
                    
  • iOS 系统框架学习（1.系统框架的四个层级）
                        码上飞
iOS框架iOS框架iOS系统
                        
    一整体框架iOS的整体系统框架图如下图所示，iOS的系统架构主要由ApplicationLayer（应用层）、CocoaTouchLayer（触摸层）、MediaLayer（媒体层）、CoreServicesLayer（核心服务层）、CoreOSLayer（核心系统操作层）和TheKernelandDeviceDriverslayer（内核和驱动层）。了解了系统架构，那么每一层的主要功能是什么呢？
    
                    
    • 
                    
  • 2018-03-20
                        HupuJRs001

                        
    MVC设计模式框架1.模型视图控制器2.框架是程序结构代码的集合。集合中包含了很多的类、函数和功能的包。3.框架学习流程了解项目的运行流程；了解tp的url模式自定义函数库；模板技术调试模式和运行状态；数据的常用操作；4.关于thinkphp面向对象mvc的设计模式丰富的查询语言详尽的文档单一入口框架5.//common存放当前目录的公共文件//conf存放当前目录的配置文件//lang存放当前目
    
                    
    • 
                    
  • 【运维测试】移动测试自动化知识总结第1篇：移动端测试介绍（md文档已分享）
                        程序员一诺
python笔记测试运维自动化servlet
                        
    本系列文章md笔记（已分享）主要讨论移动测试相关知识。主要知识点包括：移动测试分类及android环境搭建，adb常用命令，appium环境搭建及使用，pytest框架学习，PO模式，数据驱动，Allure报告，Jenkins持续集成。掌握操作app的基本api，掌握元素定位及获取元素信息的api，掌握事件操作api，掌握app模拟手势操作，掌握手机操作的api。掌握pytest函数执行顺序，掌握
    
                    
    • 
                    
  • Python Flask Web 框架学习笔记+完整项目
                        放风筝的猪
python学习笔记
                        
    Flask是一个轻量级的基于Python的web框架。我们建议使用最新版本的Python。Flask支持Python3.8及更高版本。官网：欢迎使用Flask—Flask文档（3.0.x）(palletsprojects.com)完整项目：1.简介Flask是一个轻量级的PythonWeb应用框架，它由ArminRonacher开发并由社区维护。Flask的设计理念是简单、灵活，它提供了构建Web
    
                    
    • 
                    
  • 【运维测试】移动测试自动化知识总结第1篇：移动端测试介绍（md文档已分享）
                        
python运维
                        
    本系列文章md笔记（已分享）主要讨论移动测试相关知识。主要知识点包括：移动测试分类及android环境搭建，adb常用命令，appium环境搭建及使用，pytest框架学习，PO模式，数据驱动，Allure报告，Jenkins持续集成。掌握操作app的基本api，掌握元素定位及获取元素信息的api，掌握事件操作api，掌握app模拟手势操作，掌握手机操作的api。掌握pytest函数执行顺序，掌握
    
                    
    • 
                    
  • hibernate框架学习及其与mybatis的关联
                        一览众山小-br
hibernate学习mybatis
                        
    目录一、什么是hibernate二、编写一个hibernate的maven项目三、hibernate和mybatis的对比四、hibernate的creteria和mybatis的example.creteriaGitee仓库：https://gitee.com/inandout/hibernate---nange/tree/dev/一、什么是hibernate百度百科Hibernate官网Myb
    
                    
    • 
                    
  • ruoyi若依框架分页功能实现分析
                        Gunalaer
springboot前端springboot后端javavue
                        
    系列文章ruoyi若依框架学习笔记-01ruoyi若依框架分页功能实现分析ruoyi若依框架SpringSecurity实现分析文章目录系列文章概要前端分析后端分析概要今天来分析一下若依前后端分离版本的分页功能的实现，以系统用户页面为例，从前后端一一分析。前端分析我把相关的js代码拿出来放到一起，total即分页数据的总数，和total绑定，page即页号，limit即页面数据大小限制，都和que
    
                    
    • 
                    
  • ruoyi若依框架学习笔记-01
                        Gunalaer
springboot前端学习笔记springbootvue
                        
    系列文章目录ruoyi若依框架学习笔记-01ruoyi若依框架分页实现分析ruoyi若依框架SpringSecurity实现分析文章目录系列文章目录项目结构分析项目环境要求启动项目启动后端启动前端业务模块分析验证码模块前端分析后端分析登录模块前端分析后端分析项目结构分析项目环境要求JDK>=1.8(推荐1.8版本)Mysql>=5.7.0(推荐5.7版本)Redis>=3.0Maven>=3.0N
    
                    
    • 
                    
  • ruoyi若依框架SpringSecurity实现分析
                        Gunalaer
springbootspringsecurityjavaspringboot后端
                        
    系列文章ruoyi若依框架学习笔记-01ruoyi若依框架分页实现分析ruoyi若依框架SpringSecurity实现分析文章目录系列文章前言具体分析一、项目中的SpringSecurity版本二、登录认证流程分析三、权限鉴定四、退出登录五、SpringSecurity配置类总结前言在ruoyi-vue若依框架中使用到了SpringSecurity作为认证授权的技术栈。今天，来分析一下若依中是如
    
                    
    • 
                    
  • MVC框架学习
                        zaizai1007
unityunity
                        
    大一的时候写过一个mvc框架的跑酷游戏，但是那时候基础不扎实，没学明白也没听懂。现在深入的学习一下以下内容参考：MVC模式|菜鸟教程(runoob.com)MVC模式MVC模式代表Model-View-Controller（模型-视图-控制器）模式。这种模式用于应用程序的分层开发。Model（模型）-模型代表一个存取数据的对象或JAVAPOJO。它也可以带有逻辑，在数据变化时更新控制器。从现实世界
    
                    
    • 
                    
  • Golang的学习路线
                        西木Qi
golanggolang
                        
    Golang的学习路线1基础阶段2成长阶段3进阶阶段4入门教程4.1Go语言入门教程4.2码神之路4.3李文周的博客4.4Go语言教程5其他分为三个阶段：基础阶段、成长阶段、进阶阶段。1基础阶段1、学习计算机组成、操作系统、计算机网络、数据结构、算法等，这个阶段学的越扎实越好。2成长阶段go语言基础；标准库学习；Git；MySQL、Redis；框架学习，比如Gin、Gorm、Grpc、docker
    
                    
    • 
                    
  • React前端框架学习 基础知识@stage3---week5--day2
                        英俊潇洒美少年
ReactReact框架基础知识
                        
    ReactReact学习版本：16.xReact老版本项目：15.xreact官网说17.x会使用的一些技术React应用级脚手架CRAdvaumicreate-react-app【CRA】React官网提供的脚手架脚手架：作用：快速构建一个项目安装全局安装create-react-app$npminstall-gcreate-react-app如果不想全局安装，可以直接使用npx$npxcrea
    
                    
    • 
                    
  • rtt设备驱动框架学习-框架
                        yunhuibin
rt-thread学习
                        
    rtt面向对象oopc——3.对官方IO设备模型框架图的补充绘图已学习了，这里再对照补充下。两个图，官方图和补充图。rt_device类是属于抽象类，所有子类得实现其特定的方法，这是对子类的约束，比如rt_serial，rt_spi_bus等等，给图，调用rt_decice_register，看它们都调用设备基类的这个函数来注册。他们的管理接口就是调用子类重写的方法，为啥不直接调用还要搞个函数？因
    
                    
    • 
                    
  • rtt设备驱动框架学习-spi总线和设备
                        yunhuibin
rt-thread学习
                        
    1.spi总线spi总线分为硬件spi总线和软件模拟spi总线。按照面向对象的思想，要抽象出硬件spi总线和软件spi总线的相同点和不同点。相同点就变成了spi总线基类，不同点就是各个子类的私有特性。rtt就是这么干的，共同点是什么？方法——都得有spi配置方法和数据传输方法等，于是抽象出了rt_spi_bus类。structrt_spi_bus{structrt_deviceparent;rt_
    
                    
    • 
                    
  • 前端框架学习 Vue(3)vue生命周期,钩子函数,工程化开发&脚手架CLI,组件化开发,组件分类
                        Flyoungbuhu
vue.js前端框架学习
                        
    Vue生命周期和生命周期的四个阶段Vue生命周期:一个Vue实例从创建到销毁的整个过程生命周期四个阶段:(1)创建(2)挂载(3)更新(4)销毁Vue生命周期函数(钩子函数)Vue生命周期过程中,会自动运行一些函数,被称为[生命周期钩子]->让开发者可以在[特定阶段]运行自己的代码四个阶段,八个钩子->三个常用created,mounted,beforeDestroycreated应用响应式数据准
    
                    
    • 
                    
  • Spring框架学习总结(1)
                        膨胀小白
spring学习java
                        
    一、初识SpringSpring是一个开放源代码的设计层面框架，它解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。Spring是于2003年兴起的一个轻量级的Java开发框架，由RodJohnson创建。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一栈式)轻量级开源框架1.springioc(控制反转)控制反转(Inversion
    
                    
    • 
                    
  • Spring框架学习笔记，超详细！！（1）
                        嘿嘿jisks
Spring框架学习笔记springjava后端架构
                        
    Java小白开始学习Spring框架，一方面，跟着视频学习，并记录下学习笔记，方便以后复习回顾。另一方面，发布学习笔记来约束自己，学习路程还很遥远，继续加油坚持！！！希望能帮助到大家！本期更新Spring、Spring对IoC的实现、Bean的作用域等相关知识点。另外还有我的牛客Java专项练习笔记专栏也在同步更新，希望大家多多关注，一起学习！！！1.前期1.1开闭原则OCP什么是OCP：OPC是
    
                    
    • 
                    
  • Spring框架学习笔记，超详细！！（4）
                        嘿嘿jisks
Spring框架学习笔记学习java开发语言spring后端
                        
    Java小白开始学习Spring框架，一方面，跟着视频学习，并记录下学习笔记，方便以后复习回顾。另一方面，发布学习笔记来约束自己，学习路程还很遥远，继续加油坚持！！！希望能帮助到大家！另外还有我的牛客Java专项练习笔记专栏也在同步更新，希望大家多多关注，一起学习！！！本次更新了GoF之代理模式、面向切面编程AOP、Spring对事务的支持等相关知识点。上期链接Spring框架学习笔记，超详细！！
    
                    
    • 
                                
  • java数字签名三种方式
                                    知了ing
javajdk
                                    
    以下3钟数字签名都是基于jdk7的 
1，RSA 
 

String password="test";
			// 1.初始化密钥
			KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
			keyPairGenerator.initialize(51
    
                                
    • 
                                
  • Hibernate学习笔记
                                    caoyong
Hibernate
                                    
    1>、Hibernate是数据访问层框架，是一个ORM(Object Relation Mapping)框架，作者为:Gavin King 
2>、搭建Hibernate的开发环境 
     a>、添加jar包: 
      aa>、hibernatte开发包中/lib/required/所
    
                                
    • 
                                
  • 设计模式之装饰器模式Decorator（结构型）
                                    漂泊一剑客
Decorator
                                    
    1. 概述 
 
 
       若你从事过面向对象开发，实现给一个类或对象增加行为，使用继承机制，这是所有面向对象语言的一个基本特性。如果已经存在的一个类缺少某些方法，或者须要给方法添加更多的功能（魅力），你也许会仅仅继承这个类来产生一个新类—这建立在额外的代码上。 
 
      
    
                                
    • 
                                
  • 读取磁盘文件txt，并输入String
                                    一炮送你回车库
String
                                    
    public static void main(String[] args) throws IOException { 
  
 String fileContent = readFileContent("d:/aaa.txt"); 
  
 System.out.println(fileContent); 
   

    
                                
    • 
                                
  • js三级联动下拉框
                                    3213213333332132
三级联动
                                    
    
//三级联动  
   省/直辖市<select id="province"></select>  
   市/省直辖<select id="city"></select>  
   县/区 <select id="area"></select>  
  
    
                                
    • 
                                
  • erlang之parse_transform编译选项的应用
                                    616050468
parse_transform游戏服务器属性同步abstract_code
                                    
             最近使用erlang重构了游戏服务器的所有代码，之前看过C++/lua写的服务器引擎代码，引擎实现了玩家属性自动同步给前端和增量更新玩家数据到数据库的功能，这也是现在很多游戏服务器的优化方向，在引擎层面去解决数据同步和数据持久化，数据发生变化了业务层不需要关心怎么去同步给前端。由于游戏过程中玩家每个业务中玩家数据更改的量其实是很少
    
                                
    • 
                                
  • JAVA JSON的解析
                                    darkranger
java
                                    
    
 
//		{
//			“Total”：“条数”，
//			 Code: 1,
//
//			“PaymentItems”:[
//			{
//			“PaymentItemID”:”支款单ID”,
//			“PaymentCode”:”支款单编号”,
//			“PaymentTime”:”支款日期”,
//			”ContractNo”:”合同号”，
//	
    
                                
    • 
                                
  • POJ-1273-Drainage Ditches
                                    aijuans
ACM_POJ
                                    
    POJ-1273-Drainage Ditches 
http://poj.org/problem?id=1273 
基本的最大流，按LRJ的白书写的 
 
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
#define INF 0x7fffffff
int ma
    
                                
    • 
                                
  • 工作流Activiti5表的命名及含义
                                    atongyeye
工作流Activiti
                                    
    activiti5 - http://activiti.org/designer/update在线插件安装 
 
activiti5一共23张表 
 
 
Activiti的表都以ACT_开头。 第二部分是表示表的用途的两个字母标识。 用途也和服务的API对应。 
 
ACT_RE_*: 'RE'表示repository。 这个前缀的表包含了流程定义和流程静态资源 （图片，规则，等等）。 
 
A
    
                                
    • 
                                
  • android的广播机制和广播的简单使用
                                    百合不是茶
android广播机制广播的注册
                                    
          Android广播机制简介  在Android中，有一些操作完成以后，会发送广播，比如说发出一条短信，或打出一个电话，如果某个程序接收了这个广播，就会做相应的处理。这个广播跟我们传统意义中的电台广播有些相似之处。之所以叫做广播，就是因为它只负责“说”而不管你“听不听”，也就是不管你接收方如何处理。另外，广播可以被不只一个应用程序所接收，当然也可能不被任何应
    
                                
    • 
                                
  • Spring事务传播行为详解
                                    bijian1013
javaspring事务传播行为
                                    
            在service类前加上@Transactional，声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。 
        Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这
    
                                
    • 
                                
  • eidtplus operate
                                    征客丶
eidtplus
                                    
    开启列模式: Alt+C 鼠标选择   OR   Alt+鼠标左键拖动 
列模式替换或复制内容(多行): 
右键-->格式-->填充所选内容-->选择相应操作 
OR 
Ctrl+Shift+V(复制多行数据,必须行数一致) 
 
-------------------------------------------------------
    
                                
    • 
                                
  • 【Kafka一】Kafka入门
                                    bit1129
kafka
                                    
    这篇文章来自Spark集成Kafka(http://bit1129.iteye.com/blog/2174765)，这里把它单独取出来，作为Kafka的入门吧 
  下载Kafka 
 http://mirror.bit.edu.cn/apache/kafka/0.8.1.1/kafka_2.10-0.8.1.1.tgz 
 2.10表示Scala的版本，而0.8.1.1表示Kafka
    
                                
    • 
                                
  • Spring 事务实现机制
                                    BlueSkator
spring代理事务
                                    
    Spring是以代理的方式实现对事务的管理。我们在Action中所使用的Service对象，其实是代理对象的实例，并不是我们所写的Service对象实例。既然是两个不同的对象，那为什么我们在Action中可以象使用Service对象一样的使用代理对象呢？为了说明问题，假设有个Service类叫AService，它的Spring事务代理类为AProxyService，AService实现了一个接口 
    
                                
    • 
                                
  • bootstrap源码学习与示例：bootstrap-dropdown（转帖）
                                    BreakingBad
bootstrapdropdown
                                    
    bootstrap-dropdown组件是个烂东西，我读后的整体感觉。 
一个下拉开菜单的设计： 
                  <ul class="nav pull-right">
                        <li id="fat-menu" class="dropdown">

    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-中介者模式-Mediator
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



/*
 * 中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。
 * 中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
 * 
 * 在我看来，Mediator模式是把多个对象（
    
                                
    • 
                                
  • 常用代码记录
                                    chenjunt3
UIExcelJ#
                                    
      
1、单据设置某行或某字段不能修改

//i是行号,"cash"是字段名称
getBillCardPanelWrapper().getBillCardPanel().getBillModel().setCellEditable(i, "cash", false);
//取得单据表体所有项用以上语句做循环就能设置整行了
getBillC
    
                                
    • 
                                
  • 搜索引擎与工作流引擎
                                    comsci
算法工作搜索引擎网络应用
                                    
      
 
    最近在公司做和搜索有关的工作，(只是简单的应用开源工具集成到自己的产品中)工作流系统的进一步设计暂时放在一边了，偶然看到谷歌的研究员吴军写的数学之美系列中的搜索引擎与图论这篇文章中的介绍，我发现这样一个关系(仅仅是猜想) 
  -----搜索引擎和流程引擎的基础--都是图论，至少像在我在JWFD中引擎算法中用到的是自定义的广度优先
    
                                
    • 
                                
  • oracle Health Monitor
                                    daizj
oracleHealth Monitor
                                    
    About Health Monitor 
 
Beginning with Release 11g, Oracle Database includes a framework called Health Monitor for running diagnostic checks on the database. 
 
About Health Monitor Checks 
 
Health M
    
                                
    • 
                                
  • JSON字符串转换为对象
                                    dieslrae
javajson
                                    
        作为前言,首先是要吐槽一下公司的脑残编译部署方式,web和core分开部署本来没什么问题,但是这丫居然不把json的包作为基础包而作为web的包,导致了core端不能使用,而且我们的core是可以当web来用的(不要在意这些细节),所以在core中处理json串就是个问题.没办法,跟编译那帮人也扯不清楚,只有自己写json的解析了. 
  
    
                                
    • 
                                
  • C语言学习八结构体，综合应用，学生管理系统
                                    dcj3sjt126com
C语言
                                    
    实现功能的代码： 
# include <stdio.h>
# include <malloc.h>

struct Student
{
	int age;
	float score;
	char name[100];
};


int main(void)
{
	int len;
	struct Student * pArr;
	int i,
    
                                
    • 
                                
  • vagrant学习笔记
                                    dcj3sjt126com
vagrant
                                    
    想了解多主机是如何定义和使用的, 所以又学习了一遍vagrant 
  
1. vagrant virtualbox 下载安装 
https://www.vagrantup.com/downloads.html 
https://www.virtualbox.org/wiki/Downloads 
  
查看安装在命令行输入vagrant 
  
  
2.
    
                                
    • 
                                
  • 14.性能优化-优化-软件配置优化
                                    frank1234
软件配置性能优化
                                    
    1.Tomcat线程池 
 
修改tomcat的server.xml文件： 
<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" maxThreads="1200" m
    
                                
    • 
                                
  • 一个不错的shell 脚本教程 入门级
                                    HarborChung
linuxshell
                                    
    一个不错的shell 脚本教程 入门级 
建立一个脚本 　　Linux中有好多中不同的shell，但是通常我们使用bash (bourne again shell) 进行shell编程，因为bash是免费的并且很容易使用。所以在本文中笔者所提供的脚本都是使用bash（但是在大多数情况下，这些脚本同样可以在 bash的大姐，bourne shell中运行）。 　　如同其他语言一样
    
                                
    • 
                                
  • Spring4新特性——核心容器的其他改进
                                    jinnianshilongnian
spring动态代理spring4依赖注入
                                    
    Spring4新特性——泛型限定式依赖注入 
Spring4新特性——核心容器的其他改进 
Spring4新特性——Web开发的增强 
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  
Spring4新特性——Groovy Bean定义DSL 
Spring4新特性——更好的Java泛型操作API  
Spring4新
    
                                
    • 
                                
  • Linux设置tomcat开机启动
                                    liuxingguome
tomcatlinux开机自启动
                                    
    执行命令sudo gedit /etc/init.d/tomcat6 
 
然后把以下英文部分复制过去。（注意第一句#!/bin/sh如果不写，就不是一个shell文件。然后将对应的jdk和tomcat换成你自己的目录就行了。 
 
#!/bin/bash 
 
# 
 
# /etc/rc.d/init.d/tomcat 
 
# init script for tomcat precesses
    
                                
    • 
                                
  • 第13章 Ajax进阶（下）
                                    onestopweb
Ajax
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • Troubleshooting Crystal Reports off BW
                                    blueoxygen
BO
                                    
    http://wiki.sdn.sap.com/wiki/display/BOBJ/Troubleshooting+Crystal+Reports+off+BW#TroubleshootingCrystalReportsoffBW-TracingBOE 
  
Quite useful, especially this part:  
SAP BW connectivity 
For t
    
                                
    • 
                                
  • Java开发熟手该当心的11个错误
                                    tomcat_oracle
javajvm多线程单元测试
                                    
    #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收 
测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
    
                                
    • 
                                
  • 正则表达式大全
                                    yang852220741
html编程正则表达式
                                    
    今天向大家分享正则表达式大全，它可以大提高你的工作效率 
正则表达式也可以被当作是一门语言，当你学习一门新的编程语言的时候，他们是一个小的子语言。初看时觉得它没有任何的意义，但是很多时候，你不得不阅读一些教程，或文章来理解这些简单的描述模式。 
一、校验数字的表达式 
 
数字：^[0-9]*$ 
n位的数字：^\d{n}$ 
至少n位的数字：^\d{n,}$ 
m-n位的数字：^\d{m,n}$
    
                                
    •