公司一直不是ssh零配置的框架，每次写action都要在applicationcontext和struts里面配置，好麻烦，最近有空，写了一个ssh零配置的框架
这里写了一个小的项目，以用户权限管理为例
先做准备工作：
1.struts2去官网下载最新版struts开发包http://struts.apache.org/download.cgi#struts216
2.hibernate4去官网下载最新版hibernate4开发包http://sourceforge.net/projects/hibernate/files/hibernate4/
3.spring3去官网下载最新版spring3开发包http://www.springsource.org/download/community
一、先建立一个空的web的项目sshFrame，加载必须的包
1.添加struts2必备的包。我下载的是最近的struts2.3.8
asm-3.3.jar --ASM字节码库 ，使用“cglib”则必要
aopalliance-1.0.jar --这个包为AOP提供了最普通和通用的接口
commons-fileupload-1.2.2.jar --Struts2上传下载的jar
commons-io-2.0.1.jar --Struts2上传下载的jar
commons-logging-1.1.1.jar --Jakarta的通用日志记录包
freemarker-2.3.19.jar
ognl-3.0.6.jar --支持ognl表达式
struts2-core-2.3.8.jar --struts2的核心包
struts2-spring-plugin-2.3.8.jar --struts2与spring整合所需
struts2-convention-plugin-2.3.8.jar --struts2零配置注释用
xwork-core-2.3.8.jar
可以不加 struts2-config-browser-plugin-2.3.1.1.jar为struts协助开发需要的包：可以输入http://127.0.0.1:8686/config-browser/actionNames.action查看系统所有已经存在的action,配置不正确就可以在这里看出来;
2.添加Hibernate 所需要的包。hibernate-4.1.9.Final
把下载下来的hibernate\lib\required下的包全部拷贝进去，分别是
antlr-2.7.7.jar --语言转换工具，hibernate用他将hql语句转换为sql语句
dom4j-1.6.1.jar --解析xml文档的工具
hibernate-commons-annotations-4.0.1.Final.jar
hibernate-core-4.1.9.Final.jar --核心包
hibernate-jpa-2.0-api-1.0.1.Final.jar
javassist-3.17.1-GA.jar
jboss-logging-3.1.0.GA.jar
jboss-transaction-api_1.1_spec-1.0.0.Final.jar
还有加入hibernate\lib\optional\c3p0\c3p0-0.9.1.jar
hibernate-ehcache-4.1.9.Final.jar
ehcache-core-2.4.3.jar
slf4j-api-1.6.4.jar
slf4j-log4j12-1.6.4.jar
3添加spring3 所需要的包 spring-framework-3.2.0.RELEASE
spring-aop-3.2.0.RELEASE.jar
spring-aspects-3.2.0.RELEASE.jar
spring-beans-3.2.0.RELEASE.jar
spring-context-3.2.0.RELEASE.jar
spring-core-3.2.0.RELEASE.jar
spring-expression-3.2.0.RELEASE.jar
spring-instrument-3.2.0.RELEASE.jar
spring-jdbc-3.2.0.RELEASE.jar
spring-jms-3.2.0.RELEASE.jar
spring-orm-3.2.0.RELEASE.jar
spring-oxm-3.2.0.RELEASE.jar
spring-test-3.2.0.RELEASE.jar --测试时用
spring-tx-3.2.0.RELEASE.jar --事务处理所用
spring-web-3.2.0.RELEASE.jar
aspectjweaver-1.5.3.jar --spring所依赖的包
其他
asm-commons-3.3.jar
Commons—pool.jar ,commons-dbcp.jar ----------DBCP数据库连接池，Apache的jakarta组织开发 的，tomcat连接池也是dbcp（可选）
cglib.jar----------------------------高效的代码生成工具, Hibernate用它在运行时扩展 Java类和实现 Java 接
jta.jar --标准的JTA API(JTA即java事物API，JTA事务比JDBC事务更强大。一个JTA事务可以有多个参与者，而一个JDBC事务则被限定在一个单一的数据库连接)，我暂时还没加，先备着
mysql-connector-java-5.1.18-bin.jar
log4j-1.2.16.jar
二、添加配置文件
在struts包下struts\src\apps\blank\src\main\resources提供了空白的struts.xml文件，把它复制到项目的src下
web.xml中
<!-- spring 配置 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
<description>Spring上下文</description>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext*.xml</param-value>
</context-param>
<!-- hibernate 懒加载的问题过滤 ,可以不配置 -->
<filter>
<description>hibernate Session 过滤器</description>
<filter-name>openSessionInViewFilter</filter-name>
<filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>openSessionInViewFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter>
<!-- struts配置 -->
<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>
struts.xml配置
<struts>
<!-- 使用Spring -->
<constant name="struts.objectFactory" value="spring" />
<constant name="struts.devMode" value="true" />
<constant name="struts.configuration.xml.reload" value="true" />
<package name="default" extends="struts-default" namespace="/">
<interceptors>
<!-- 使用权限拦截 -->
<interceptor name="authority" class="com.sshFrame.zero.interceptor.AuthorityInterceptor"/>
<!-- 异常拦截 -->
<interceptor name="exceptionInterceptor" class="com.sshFrame.zero.interceptor.ExceptionInterceptor"/>
<!-- 解决struts安全漏洞，拦截所有的带有#号的url -->
<interceptor-stack name="baseStack">
<interceptor-ref name="authority"/>
<interceptor-ref name="exceptionInterceptor"/>
<interceptor-ref name="params">
<param name="excludeParams">.*\\u0023.*</param>
</interceptor-ref>
<interceptor-ref name="defaultStack"/>
</interceptor-stack>
</interceptors>
<!-- 配置默认拦截器栈 -->
<default-interceptor-ref name="baseStack"/>
<global-results>
<result name="login">/index.jsp</result>
<result name="error">/error.jsp</result>
</global-results>
</package>
</struts>
applicationcontext.xml配置：
<?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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:dwr="http://www.directwebremoting.org/schema/spring-dwr"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/osdesignaid"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.current_session_context_class">thread</prop>
<prop key="hibernate.cache.region.factory_class">org.hibernate.cache.EhCacheRegionFactory</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
<property name="packagesToScan">
<list>
<value>com.sshFrame.zero.pojo</value>
<value>com.sshFrame.test.pojo</value>
</list>
</property>
</bean>
<aop:aspectj-autoproxy /><!-- 代理 -->
<!-- 定义事务管理器 -->
<bean id="txManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- 申明annotation 加载事务驱动 -->
<tx:annotation-driven transaction-manager="txManager" proxy-target-class="true"/>
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED" />
<tx:method name="add*" propagation="REQUIRED" />
<tx:method name="create*" propagation="REQUIRED" />
<tx:method name="insert*" propagation="REQUIRED" />
<tx:method name="update*" propagation="REQUIRED" />
<tx:method name="merge*" propagation="REQUIRED" />
<tx:method name="del*" propagation="REQUIRED" />
<tx:method name="remove*" propagation="REQUIRED" />
<tx:method name="put*" propagation="REQUIRED" />
<tx:method name="use*" propagation="REQUIRED"/>
<!--hibernate4必须配置为开启事务 否则 getCurrentSession()获取不到-->
<tx:method name="get*" propagation="REQUIRED" read-only="true" />
<tx:method name="count*" propagation="REQUIRED" read-only="true" />
<tx:method name="find*" propagation="REQUIRED" read-only="true" />
<tx:method name="list*" propagation="REQUIRED" read-only="true" />
<tx:method name="*" read-only="true" />
</tx:attributes>
</tx:advice>
<aop:config expose-proxy="true">
<!-- 只对业务逻辑层实施事务 -->
<aop:pointcut id="txPointcut" expression="execution(* cn.javass..service..*.*(..))" />
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
</aop:config>
<!-- 自动扫描包 -->
<context:annotation-config />
<context:component-scan base-package="com.sshFrame.zero.*,com.sshFrame.test.*" annotation-config="true"/>
</beans>
配置都写好了，
改写基本的框架类了
Basedao
package com.sshFrame.zero.dao;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import javax.persistence.Id;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Example;
import org.springframework.beans.factory.annotation.Autowired;
/**
* 基于hibernate的BaseDao
* Spring3对Hibernate4已经没有了HibernateDaoSupport和HibernateTemplate的支持，使用了原生态的API
* @author 雪精灵
*
* @param <T>
*/
public class BaseDao<T extends Serializable> {
@Autowired
private SessionFactory sessionFactory;
//当前泛型类
@SuppressWarnings("rawtypes")
private Class entityClass;
//当前主键名称
private String pkname;
private final String HQL_LIST_ALL;
private final String HQL_COUNT_ALL;
@SuppressWarnings("rawtypes")
public Class getEntityClass() {
return entityClass;
}
@SuppressWarnings("rawtypes")
public void setEntityClass(Class entityClass) {
this.entityClass = entityClass;
}
@SuppressWarnings("rawtypes")
public BaseDao() {
//获取当前泛型类
Type type = this.getClass().getGenericSuperclass();
if (type.toString().indexOf("BaseDao") != -1) {
ParameterizedType type1 = (ParameterizedType) type;
Type[] types = type1.getActualTypeArguments();
setEntityClass((Class) types[0]);
}else{
type = ((Class)type).getGenericSuperclass();
ParameterizedType type1 = (ParameterizedType) type;
Type[] types = type1.getActualTypeArguments();
setEntityClass((Class) types[0]);
}
getPkname();
HQL_LIST_ALL="from "+this.entityClass.getSimpleName()+" order by "+pkname+" desc";
HQL_COUNT_ALL="select count(*) from "+this.entityClass.getSimpleName();
}
/**
* 获取主键名称
* @return
*/
public String getPkname() {
Field[] fields = this.entityClass.getDeclaredFields();//反射类字段
for (Field field : fields) {
field.isAnnotationPresent(Id.class);
this.pkname=field.getName();
break;
}
return pkname;
}
/**
* 保存实例
*
* @param t
* @throws HibernateException
*/
public void save(T t) throws HibernateException{
Session session=null;
try {
session=sessionFactory.openSession();
session.beginTransaction();
session.save(t);
session.getTransaction().commit();
} catch (HibernateException e) {
e.printStackTrace();
throw new HibernateException(e);
}finally{
session.close();
}
}
/**
* 修改实例
*
* @param t
* @throws HibernateException
*/
public void update(T t) throws HibernateException{
Session session=null;
try {
session=sessionFactory.openSession();
session.beginTransaction();
session.update(t);
session.getTransaction().commit();
} catch (HibernateException e) {
e.printStackTrace();
throw new HibernateException(e);
}finally{
session.close();
}
}
/**
* 删除实例
*
* @param t
* @throws HibernateException
*/
public void delete(T t) throws HibernateException{
Session session=null;
try {
session=sessionFactory.openSession();
session.beginTransaction();
session.delete(t);
session.getTransaction().commit();
} catch (HibernateException e) {
e.printStackTrace();
throw new HibernateException(e);
}finally{
session.close();
}
}
/**
* 获取实例
*
* @param id
* @throws HibernateException
*/
@SuppressWarnings("unchecked")
public T get(Serializable id) throws Exception{
Session session=null;
T t=null;
try {
session=sessionFactory.openSession();
session.beginTransaction();
t=(T) session.get(getEntityClass(), id);
session.getTransaction().commit();
} catch (HibernateException e) {
e.printStackTrace();
throw new HibernateException(e);
}finally{
session.close();
}
return t;
}
/**
* 查询全部
*
* @throws HibernateException
*/
@SuppressWarnings("unchecked")
public List<T> findAll() throws Exception {
List<T> list=null;
Session session=null;
try {
session = sessionFactory.openSession();
session.beginTransaction();
Query query = session.createQuery(HQL_LIST_ALL);
list = query.list();
session.getTransaction().commit();
} catch (HibernateException e) {
e.printStackTrace();
}finally{
session.close();
}
return list;
}
/**
* 查询总数
*
* @throws HibernateException
*/
public Integer findAllCount() throws Exception {
Session session=null;
Integer count=0;
try {
session = sessionFactory.openSession();
session.beginTransaction();
Query query = session.createQuery(HQL_COUNT_ALL);
List<?> list = query.list();
session.getTransaction().commit();
if(list!=null&&!list.isEmpty()){
count=((Integer) list.get(0)).intValue();
}
} catch (HibernateException e) {
e.printStackTrace();
}finally{
session.close();
}
return count;
}
/**
* QBC查询
*
* @param criteria
* @throws HibernateException
*/
@SuppressWarnings("unchecked")
public List<T> findByCriteria(Criteria criteria) throws Exception {
List<T> list=null;
Session session=null;
try {
session = sessionFactory.openSession();
session.beginTransaction();
Criteria criteria1 = session.createCriteria(getEntityClass());
criteria1=criteria;
list = criteria1.list();
session.getTransaction().commit();
} catch (HibernateException e) {
e.printStackTrace();
}finally{
session.close();
}
return list;
}
/**
* QBE查询
*
* @param t
* @throws HibernateException
*/
@SuppressWarnings("unchecked")
public List<T> findByExample(T t) throws Exception {
List<T> list=null;
Session session=null;
Example example = Example.create(t);
try {
session = sessionFactory.openSession();
session.beginTransaction();
Criteria criteria = session.createCriteria(getEntityClass());
criteria.add(example);
list = criteria.list();
session.getTransaction().commit();
} catch (HibernateException e) {
e.printStackTrace();
}finally{
session.close();
}
return list;
}
/**
* HQL查询
*
* @param hql
* @param objects
* @throws HibernateException
*/
@SuppressWarnings("unchecked")
public List<Object[]> findByHql(String hql,final Object...objects) throws Exception{
List<Object[]> list=null;
Session session=null;
try {
session=sessionFactory.openSession();
session.beginTransaction();
Query query = session.createQuery(hql);
for (int i = 0; i < objects.length; i++) {
query.setParameter(i, objects[i]);
}
list = query.list();
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
}finally{
session.close();
}
return list;
}
/**
* SQL查询
*
* @param hql
* @param objects
* @throws HibernateException
*/
@SuppressWarnings("unchecked")
public List<Object[]> findBySql(String sql,final Object...objects){
List<Object[]> list=null;
Session session=null;
try {
session=sessionFactory.openSession();
session.beginTransaction();
Query query = sessionFactory.getCurrentSession().createSQLQuery(sql);
for (int i = 0; i < objects.length; i++) {
query.setParameter(i, objects[i]);
}
list = query.list();
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
}finally{
session.close();
}
return list;
}
}
BaseService
package com.sshFrame.zero.service;
import java.io.Serializable;
import java.util.List;
import com.sshFrame.zero.dao.BaseDao;
/**
* @author 雪精灵
*
* @param
*/
public class BaseService<T extends Serializable> {
protected BaseDao<T> baseDao;
public void save(T t) throws Exception{
baseDao.save(t);
}
public void update(T t) throws Exception{
baseDao.update(t);
}
public void delete(T t) throws Exception{
baseDao.delete(t);
}
public T get(Serializable id) throws Exception{
return baseDao.get(id);
}
public List<T> findAll() throws Exception{
return baseDao.findAll();
}
public List<T> findByExample(T t) throws Exception{
return baseDao.findByExample(t);
}
public BaseDao<T> getBaseDao() {
return baseDao;
}
public void setBaseDao(BaseDao<T> baseDao) {
this.baseDao = baseDao;
}
}
先上7个pojo
package com.sshFrame.zero.pojo;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="userinfo")
public class Userinfo implements Serializable{
private static final long serialVersionUID = 1L;
private String userid;
private String username;
private String password;
private String depid;
private String dutyid;
private Set<Userrole> userroles=new HashSet<Userrole>();
@GenericGenerator(name = "generator", strategy = "uuid")
@Id
@GeneratedValue(generator = "generator")
@Column(name = "userid", unique = true, nullable = false, length = 50)
public String getUserid() {
return userid;
}
public void setUserid(String userid) {
this.userid = userid;
}
@Column(name = "username", nullable = false, length = 50)
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
@Column(name = "password", nullable = false, length = 50)
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Column(name = "depid", nullable = false, length = 50)
public String getDepid() {
return depid;
}
public void setDepid(String depid) {
this.depid = depid;
}
@Column(name = "dutyid", nullable = false, length = 50)
public String getDutyid() {
return dutyid;
}
public void setDutyid(String dutyid) {
this.dutyid = dutyid;
}
@OneToMany(cascade=CascadeType.REMOVE,mappedBy="userinfo",fetch=FetchType.LAZY)
public Set<Userrole> getUserroles() {
return userroles;
}
public void setUserroles(Set<Userrole> userroles) {
this.userroles = userroles;
}
}
package com.sshFrame.zero.pojo;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="role")
public class Role implements Serializable{
private static final long serialVersionUID = 1L;
private String id;
private String name;
private Set<Userrole> userroles=new HashSet<Userrole>();
private Set<Rolerights> rolerights=new HashSet<Rolerights>();
@GenericGenerator(name = "generator", strategy = "uuid")
@Id
@GeneratedValue(generator = "generator")
@Column(name = "id", unique = true, nullable = false, length = 50)
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
@Column(name = "name", nullable = false, length = 50)
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@OneToMany(cascade=CascadeType.REMOVE,fetch=FetchType.LAZY,mappedBy="role")
public Set<Userrole> getUserroles() {
return userroles;
}
public void setUserroles(Set<Userrole> userroles) {
this.userroles = userroles;
}
@OneToMany(cascade=CascadeType.REMOVE,fetch=FetchType.LAZY,mappedBy="role")
public Set<Rolerights> getRolerights() {
return rolerights;
}
public void setRolerights(Set<Rolerights> rolerights) {
this.rolerights = rolerights;
}
}
package com.sshFrame.zero.pojo;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="rights")
public class Rights implements Serializable{
private static final long serialVersionUID = 1L;
private String id;
private String name;
private Set<Rolerights> rolerights=new HashSet<Rolerights>();
@GenericGenerator(name = "generator", strategy = "uuid")
@Id
@GeneratedValue(generator = "generator")
@Column(name = "id", unique = true, nullable = false, length = 50)
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
@Column(name = "name", nullable = false, length = 50)
public void setName(String name) {
this.name = name;
}
@OneToMany(cascade=CascadeType.REMOVE,fetch=FetchType.LAZY,mappedBy="rights")
public Set<Rolerights> getRolerights() {
return rolerights;
}
public void setRolerights(Set<Rolerights> rolerights) {
this.rolerights = rolerights;
}
}
package com.sshFrame.zero.pojo;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="resources")
public class Resources implements Serializable{
private static final long serialVersionUID = 1L;
private String id;
private String name;
private String url;
private Set<Rightsresources> rightsresourcs=new HashSet<Rightsresources>();
@GenericGenerator(name = "generator", strategy = "uuid")
@Id
@GeneratedValue(generator = "generator")
@Column(name = "id", unique = true, nullable = false, length = 50)
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
@Column(name = "name", nullable = false, length = 50)
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Column(name = "url", nullable = false, length = 100)
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
@OneToMany(cascade=CascadeType.REMOVE,fetch=FetchType.LAZY,mappedBy="resources")
public Set<Rightsresources> getRightsresourcs() {
return rightsresourcs;
}
public void setRightsresourcs(Set<Rightsresources> rightsresourcs) {
this.rightsresourcs = rightsresourcs;
}
}
package com.sshFrame.zero.pojo;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="userrole")
public class Userrole implements Serializable{
private static final long serialVersionUID = 1L;
private String id;
private Userinfo userinfo;
private Role role;
@GenericGenerator(name = "generator", strategy = "uuid")
@Id
@GeneratedValue(generator = "generator")
@Column(name = "id", unique = true, nullable = false, length = 50)
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name="userid")
public Userinfo getUserinfo() {
return userinfo;
}
public void setUserinfo(Userinfo userinfo) {
this.userinfo = userinfo;
}
@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name="roleid")
public Role getRole() {
return role;
}
public void setRole(Role role) {
this.role = role;
}
}
package com.sshFrame.zero.pojo;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="rolerights")
public class Rolerights implements Serializable{
private static final long serialVersionUID = 1L;
private String id;
private Role role;
private Rights rights;
@GenericGenerator(name = "generator", strategy = "uuid")
@Id
@GeneratedValue(generator = "generator")
@Column(name = "id", unique = true, nullable = false, length = 50)
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name="roleid")
public Role getRole() {
return role;
}
public void setRole(Role role) {
this.role = role;
}
@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name="rightsid")
public Rights getRights() {
return rights;
}
public void setRights(Rights rights) {
this.rights = rights;
}
}
package com.sshFrame.zero.pojo;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="rightsresources")
public class Rightsresources implements Serializable{
private static final long serialVersionUID = 1L;
private String id;
private Rights rights;
private Resources resources;
@GenericGenerator(name = "generator", strategy = "uuid")
@Id
@GeneratedValue(generator = "generator")
@Column(name = "id", unique = true, nullable = false, length = 50)
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name="rightsid")
public Rights getRights() {
return rights;
}
public void setRights(Rights rights) {
this.rights = rights;
}
@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name="resourcesid")
public Resources getResources() {
return resources;
}
public void setResources(Resources resources) {
this.resources = resources;
}
}
UserinfoService 这个一定要注意，要在setUserinfoDao方法里把当前的dao给basedao，否则，basedao会报空指针
package com.sshFrame.zero.service.users;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import com.sshFrame.zero.dao.users.UserinfoDao;
import com.sshFrame.zero.pojo.Userinfo;
import com.sshFrame.zero.service.BaseService;
/**
* 用户管理
* @author 雪精灵
*
* @param
*/
@Service
@Component("userinfoService")
public class UserinfoService extends BaseService<Userinfo>{
private UserinfoDao userinfoDao;
public UserinfoService() {
super();
}
public Userinfo findlogin(String username,String password) throws Exception{
Userinfo userinfo=new Userinfo();
userinfo.setUsername(username);
userinfo.setPassword(password);
List<Userinfo> userinfos = findByExample(userinfo);
if(userinfos!=null&&!userinfos.isEmpty()){
userinfo=userinfos.get(0);
}else{
userinfo=null;
}
return userinfo;
}
public List<?> used(String userid,String url) throws Exception {
String hql="select ur.userinfo.userid,re.name,re.url from Userrole ur,Role r,Rolerights rr,Rights ri,Rightsresources rs,Resources re "+
"where ur.role.id=r.id and r.id=rr.role.id and rr.rights.id=ri.id and ri.id=rs.rights.id and rs.resources.id=re.id and "+
"ur.userinfo.userid=? and re.url=?";
List<?> userResource = userinfoDao.findByHql(hql,userid,url);
return userResource;
}
public UserinfoDao getUserinfoDao() {
return userinfoDao;
}
/**
* 一定要用set方法注入，并赋值给baseDao，否则baseDao为null;
* 只适用于注入一个Dao
* @param userinfoDao
*/
@Autowired
public void setUserinfoDao(UserinfoDao userinfoDao) {
super.setBaseDao(userinfoDao);
this.userinfoDao = userinfoDao;
}
}
package com.sshFrame.zero.action.users;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Namespace;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.interceptor.ServletRequestAware;
import org.apache.struts2.interceptor.ServletResponseAware;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import com.opensymphony.xwork2.ActionSupport;
import com.sshFrame.zero.pojo.Userinfo;
import com.sshFrame.zero.service.users.UserinfoService;
/**
* @author 雪精灵
*
*
*/
@Namespace("/")
@Scope("prototype")
@Component("userinfoAction")
public class UserinfoAction extends ActionSupport implements ServletRequestAware,ServletResponseAware{
private static final long serialVersionUID = 1L;
private HttpServletRequest request;
private HttpServletResponse response;
@Autowired
private UserinfoService userinfoService;
@Action(value="login",results={
@Result(name="success",location="init.jsp"),
@Result(name="failure",location="/index.jsp")
})
public String login(){
String username=request.getParameter("username");
String password=request.getParameter("password");
Userinfo userinfo=null;
try {
userinfo = userinfoService.findlogin(username, password);
} catch (Exception e) {
e.printStackTrace();
}
if(userinfo==null){
request.setAttribute("msg", "用户名或密码错误");
return "failure";
}else{
request.getSession().setAttribute("userid", userinfo.getUserid());
}
return "success";
}
public boolean used(String userid,String url) {
List<?> list=null;
try {
list = userinfoService.used(userid, url);
} catch (Exception e) {
e.printStackTrace();
return false;
}
if(list!=null&&!list.isEmpty()){
return true;
}
return false;
}
@Override
public void setServletResponse(HttpServletResponse response) {
this.response=response;
}
@Override
public void setServletRequest(HttpServletRequest request) {
this.request=request;
}
public UserinfoService getUserinfoService() {
return userinfoService;
}
public void setUserinfoService(UserinfoService userinfoService) {
this.userinfoService = userinfoService;
}
}
package com.sshFrame.zero.action.users;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Namespace;
import org.apache.struts2.convention.annotation.ParentPackage;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.interceptor.ServletRequestAware;
import org.apache.struts2.interceptor.ServletResponseAware;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import com.opensymphony.xwork2.ActionSupport;
import com.sshFrame.zero.service.users.UserinfoService;
/**
* @author 雪精灵
*
*
*/
@Namespace("/admin")
@ParentPackage("default")
@Scope("prototype")
public class AdminAction extends ActionSupport implements ServletRequestAware,ServletResponseAware{
private static final long serialVersionUID = 1L;
@Autowired
private UserinfoService userinfoService;
private HttpServletRequest request;
private HttpServletResponse response;
@Action(value="init",results={@Result(name="success",location="main.jsp"),
@Result(name="failure",location="/index.jsp")})
public String init(){
String userid=(String) request.getSession().getAttribute("userid");
System.out.println(userid);
return SUCCESS;
}
public UserinfoService getUserinfoService() {
return userinfoService;
}
public void setUserinfoService(UserinfoService userinfoService) {
this.userinfoService = userinfoService;
}
@Override
public void setServletResponse(HttpServletResponse response) {
this.response=response;
}
@Override
public void setServletRequest(HttpServletRequest request) {
this.request=request;
}
}
下面加入拦截器
package com.sshFrame.zero.interceptor;
import javax.servlet.http.HttpServletRequest;
import org.apache.struts2.ServletActionContext;
import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
import com.sshFrame.zero.action.users.UserinfoAction;
import com.sshFrame.zero.exception.AhCustomException;
import com.sshFrame.zero.exception.AhCustomException.ExcCode;
/**
* 用户权限拦截器，在struts.xml中配置
* @author 雪精灵
*/
public class AuthorityInterceptor extends AbstractInterceptor{
private static final long serialVersionUID = 2914081148619842225L;
private UserinfoAction userinfoAction;
@Override
public String intercept(ActionInvocation invocation) throws Exception {
HttpServletRequest request = ServletActionContext.getRequest();
// String method = invocation.getProxy().getMethod();
// String actionName=invocation.getInvocationContext().getName();
String userid = (String) request.getSession().getAttribute("userid");
if(userid==null||"".equals(userid)){
request.setAttribute("msg",AhCustomException.getExcMessage(ExcCode.Unlogined));
return Action.ERROR;
}
//获取项目路径
String contextPath=request.getServletContext().getContextPath();
//获取当前路径
String uri = request.getRequestURI();
//当前相对项目的路径
String actionUrl=uri.replace(contextPath, "");
boolean used = userinfoAction.used(userid, actionUrl);
if(used){
return invocation.invoke();
}else{
request.setAttribute("msg",AhCustomException.getExcMessage(ExcCode.InvalidRights));
return Action.ERROR;
}
}
public UserinfoAction getUserinfoAction() {
return userinfoAction;
}
public void setUserinfoAction(UserinfoAction userinfoAction) {
this.userinfoAction = userinfoAction;
}
}
package com.sshFrame.zero.interceptor;
import javax.servlet.http.HttpServletRequest;
import org.apache.log4j.Logger;
import org.apache.struts2.ServletActionContext;
import org.hibernate.HibernateException;
import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
import com.sshFrame.zero.exception.AhCustomException;
import com.sshFrame.zero.exception.AhCustomException.ExcCode;
/**
* 错误权限拦截器，在struts.xml中配置
* @author 雪精灵
*/
public class ExceptionInterceptor extends AbstractInterceptor{
private Logger logger=Logger.getLogger(ExceptionInterceptor.class);
private static final long serialVersionUID = -3490533736557683231L;
private String excMessage="";
@Override
public String intercept(ActionInvocation invocation) throws Exception {
String result;
HttpServletRequest request = ServletActionContext.getRequest();
String uri = request.getRequestURI();
try {
result = invocation.invoke();
} catch (HibernateException e) {
e.printStackTrace();
logger.error("异常拦截器拦截到异常:"+"<br/>"+"uri为:"+uri+"<br/>"+e);
excMessage=AhCustomException.getExcMessage(ExcCode.DataProcessing);
request.setAttribute("msg", excMessage);
result=Action.ERROR;
}catch (NullPointerException e) {
e.printStackTrace();
logger.error("异常拦截器拦截到异常:"+"<br/>"+"action的名称为:"+uri+"<br/>"+e);
excMessage=AhCustomException.getExcMessage(ExcCode.IllegalData);
request.setAttribute("msg", excMessage);
result=Action.ERROR;
}catch (AhCustomException e) {
e.printStackTrace();
logger.error("异常拦截器拦截到异常:"+"<br/>"+"action的名称为:"+uri+"<br/>"+e);
excMessage=e.getExcMessage();
request.setAttribute("msg", excMessage);
result=Action.ERROR;
}catch (Exception e) {
e.printStackTrace();
logger.error("异常拦截器拦截到异常:"+"<br/>"+"action的名称为:"+uri+"<br/>"+e);
excMessage=AhCustomException.getExcMessage(ExcCode.AppError);
request.setAttribute("msg", excMessage);
result=Action.ERROR;
}
return result;
}
}
自定义异常类
package com.sshFrame.zero.exception;
/**
* 自定义异常处理
* @author 雪精灵
*/
public class AhCustomException extends Exception{
private static final long serialVersionUID = 1L;
/**
* 错误类型标识
*/
private ExcCode excCode = null;
public enum ExcCode{
AppError,
InvalidRights,
IllegalData,
DataProcessing,
Unlogined
}
public static final String[] excMessage = {
"内部异常",
"您没有执行本操作的权限",
"提供的数据为空或不合法",
"数据处理异常",
"您可能还没有登录本系统，或者已经超时，您必须先登录本系统后才能使用该功能<p><a href='../' target='_parent'>重新登录</a></p>"
};
public AhCustomException(){
super(getExcMessage(ExcCode.AppError));
excCode = ExcCode.AppError;
}
/**
* 构造函数
*
* @param arg0
* 错误类型标识
*/
public AhCustomException(ExcCode excCode) {
super(getExcMessage(excCode));
this.excCode = excCode;
}
/**
* 根据错误类型标识获取错误信息
*
* @param emFlag
* 错误类型标识
*
* @return 错误信息
*/
public static String getExcMessage(ExcCode excCode) {
return excMessage[excCode.ordinal()];
}
public String getExcMessage() {
return excMessage[excCode.ordinal()];
}
/**
* 构造函数
*
* @param arg0
* 错误类型标识
*
* @param arg1
* 被包含的异常对象
*/
public AhCustomException(ExcCode excCode, Throwable throwable) {
super(getExcMessage(excCode), throwable);
setStackTrace(throwable.getStackTrace());
this.excCode = excCode;
}
/**
* 构造函数
*
* @param arg0
* 被包含的异常对象
*/
public AhCustomException(Throwable throwable) {
super(getExcMessage(throwable.getClass() == AhCustomException.class ? ((AhCustomException) throwable).excCode : ExcCode.AppError), throwable);
setStackTrace(throwable.getStackTrace());
if (throwable.getClass() == AhCustomException.class)
excCode = ((AhCustomException) throwable).excCode;
else
excCode = excCode.AppError;
}
}
下面加入页面，index.jsp,在webContent下
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'index.jsp' starting page</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<!--
<link rel="stylesheet" type="text/css" href="styles.css">
-->
</head>
<body>
${msg }
<form action="login" method="post">
<table>
<tbody>
<tr><td>用户名：</td><td><input type="text" name="username"/></td></tr>
<tr><td>密码：</td><td><input type="password" name="password"/></td></tr>
<tr><td colspan="2"><input type="submit" value="Login"/></td></tr>
</tbody>
</table>
</form>
</body>
</html>
init.jsp.在web-inf/content/下
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'init.jsp' starting page</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<!--
<link rel="stylesheet" type="text/css" href="styles.css">
-->
<script type="text/javascript">
window.onload=function(){
window.location.href="admin/init";
}
</script>
</head>
<body>
欢迎进入
</body>
</html>
程序下载链接：http://download.csdn.net/detail/doublelucklysnow/5001504
相关推荐
内容概要：本文详细介绍了低成本单发单收激光测距传感器的一站式解决方案，涵盖硬件设计、软件实现及其应用。硬件部分基于STM32F030F4P6芯片，搭配激光发射管和APD接收模块，通过精心设计的信号调理电路确保高精度测量。软件部分展示了关键代码片段，如初始化、测距算法和ADC配置，采用改进型飞行时间法（ToF）并通过DMA优化数据处理效率。此外，文章还讨论了调试过程中遇到的问题及解决方案，如环境光干扰和PCB布局优化。最终，该方案实现了0.05-50米范围内±1.5mm的测距精度，适用于多种应用场景。 适合人群：电子爱好者、硬件工程师、嵌入式系统开发者。 使用场景及目标：① DIY爱好者可以通过本方案进行个人项目的开发；② 企业可以基于此方案进行商业产品的开发，降低成本；③ 教育机构可以用作教学案例，帮助学生理解激光测距原理和技术实现。 其他说明：文章不仅提供详细的硬件和软件设计方案，还包括BOM清单、供应商信息和调试指南，有助于快速实现和优化项目。
内容概要：本文详细介绍了将麻雀算法（SSA）应用于LSTM参数优化的方法及其MATLAB实现。首先，通过生成带噪声的正弦波数据模拟真实场景的数据扰动，然后定义适应度函数用于评估LSTM模型的表现。接着，利用麻雀算法的发现者和跟随者角色进行参数优化，最终实现了比随机调参更好的预测效果。文中不仅提供了完整的代码实现，还讨论了参数设置的经验值以及一些实用技巧，如数据归一化、早停机制和并行加速等。 适合人群：对机器学习尤其是深度学习有一定了解的研究人员和技术爱好者，熟悉MATLAB编程环境。 使用场景及目标：适用于需要提高时间序列预测精度的任务，如金融数据分析、天气预报等领域。主要目标是通过引入生物启发式的优化算法来提升LSTM模型的性能。 其他说明：文中提到的麻雀算法能够显著减少人工调参的工作量，并且相比传统的网格搜索法更加高效。此外，作者还分享了一些实践经验，帮助读者更好地理解和应用这一方法。
内容概要：本文详细介绍了使用西门子Smart200 PLC实现高效的星三角降压启动子程序的方法。作者分享了具体的编程技巧，包括参数化的外部配置、定时器的巧妙运用以及故障处理机制。文中展示了完整的主程序调用示例和子程序内部逻辑，强调了模块化编程的优势，使得不同电机可以轻松复用相同的子程序，极大提高了调试和维护效率。此外，作者还提到了一些常见的调试陷阱和优化建议，如避免星三角同时导通、合理设置切换时间和加入硬件互锁等。 适合人群：从事PLC编程、自动化控制领域的工程师和技术人员，尤其是那些希望提高编程效率和代码复用性的从业者。 使用场景及目标：适用于需要频繁进行电机星三角降压启动的工业应用场景，如纺织厂、水泥厂等。主要目标是通过模块化编程减少重复劳动，提升系统稳定性和响应速度。 其他说明：文章不仅提供了详细的代码示例，还分享了许多实践经验，帮助读者更好地理解和应用这些技术。
2025中国数字营销趋势报告.pdf
内容概要：本文详细介绍了如何利用两台威纶通MT6071iP触摸屏控制一台信捷PLC的具体步骤和技术要点。主要内容涵盖硬件连接、触摸屏设置、PLC编程、调试与优化等方面。文中不仅提供了具体的配置方法，如通讯参数设置、画面设计、宏指令处理等，还分享了许多实际操作中的经验和注意事项，如地址分配、数据同步、通讯稳定性提升等。 适合人群：从事工业自动化领域的工程师和技术人员，尤其是那些需要实现多屏协同控制PLC系统的工作者。 使用场景及目标：适用于需要提高生产线上设备操作便捷性和监控灵活性的场合。通过一机多屏设置，可以在不同位置对同一PLC进行控制，方便现场操作和远程管理。 其他说明：文章强调了硬件连接细节、通讯参数一致性、PLC编程逻辑的重要性，并提供了一些实用技巧，如宏指令处理、心跳检测、防呆设计等，帮助读者更好地理解和实施该项目。
2024中国上市公司数字化转型报告.pdf
内容概要：《2024年中国物联网产业创新白皮书》由深圳市物联网产业协会与AIoT星图研究院联合编制，汇集了全国30多个省市物联网组织的智慧。白皮书系统梳理了中国物联网产业的发展历程、现状及未来趋势，涵盖了物联网的概念、产业结构、市场规模、投融资情况、面临的问题与机遇。书中详细分析了感知层、传输层、平台层及应用层的关键技术，探讨了智慧城市、智能工业、车联网、智慧医疗等九大产业物联网应用领域，以及消费物联网的发展特征与热门单品。此外，白皮书还关注了物联网数据安全、法规遵从、人才短缺等挑战，并提出了相应的解决方案。 适用人群：物联网从业者、企业决策者、政策制定者及相关研究机构。 使用场景及目标：①帮助从业者深入了解物联网产业的现状和发展趋势；②为企业决策者提供战略规划依据；③为政策制定者提供政策支持和法规制定参考；④为研究机构提供详尽的数据和案例支持。 其他说明：白皮书不仅限于技术科普，更从宏观角度结合市场情况，多维度讨论了物联网产业生态，旨在为物联网企业、从业者找到最适合的技术应用场景，促进产业健康发展。报告还特别鸣谢了参与市场调研的企业，感谢他们提供的宝贵行业信息。由于时间和资源的限制，报告可能存在信息不充分之处，欢迎各界人士提出宝贵意见。
内容概要：本文详细介绍了汇川H5U PLC中采用结构体编程的优势及其具体应用场景。作者通过多个实际项目案例展示了结构体编程如何显著提高代码的整洁度、可维护性和扩展性。文中特别强调了结构体在处理大量相似设备（如气缸、阀门、伺服轴）时的作用，以及如何利用结构体简化变量管理、增强在线调试体验并减少内存消耗。此外，还讨论了一些常见的注意事项和技术细节，如结构体初始化、功能块集成、在线修改功能的应用等。 适用人群：从事工业自动化系统开发的技术人员，尤其是对PLC编程有一定经验的工程师。 使用场景及目标：适用于需要高效管理和维护复杂工业控制系统的场合，旨在帮助工程师更好地理解和掌握结构体编程技巧，从而提高工作效率和代码质量。 其他说明：文章提供了丰富的代码片段作为示例，便于读者直观地理解结构体编程的具体实现方法。同时提醒读者注意结构体初始化等问题，确保项目顺利进行。
内容概要：本文介绍了如何利用数学建模替代传统的电气元件仿真，实现三相逆变器的模型预测控制（MPC）。主要内容包括三相桥的数学模型建立、代价函数设计、状态方程离散化以及仿真优化技巧。通过将三相桥的输出电压转换为矩阵运算，减少了计算复杂度，提高了仿真速度。代价函数不仅考虑了电流跟踪误差，还加入了开关频率惩罚项，以减少不必要的开关动作。此外，文中提供了详细的代码示例，展示了如何通过数学建模实现高效的MPC控制。 适合人群：从事电力电子控制系统设计的研究人员和技术人员，尤其是对三相逆变器及其控制算法感兴趣的读者。 使用场景及目标：适用于需要快速迭代和验证控制算法的场合，如光伏并网、电机驱动等领域。目标是提高仿真效率，优化控制性能，减少开发时间和成本。 其他说明：文中提到的技术手段能够显著提升仿真速度，但在应用时需要注意数值稳定性和参数辨识的准确性。
内容概要：本文详细介绍了如何使用MATLAB/Simulink构建并仿真一个60W的Flyback变换器模型，输入为390V直流，输出为19V/3A。主要内容涵盖主电路搭建（包括变压器参数设置、MOSFET选择）、吸收电路设计（RCD参数调整）、闭环控制系统（PID参数调节）以及动态性能测试。文中还提供了多个实用技巧，如防止变压器饱和、优化吸收电路参数、提高动态响应速度等，并指出了常见的错误及其解决方案。同时，推荐了几本相关领域的经典书籍供进一步学习。 适合人群：初学者和有一定基础的电源设计师，特别是希望深入了解Flyback变换器工作原理和技术细节的人群。 使用场景及目标：适用于需要进行中小功率电源设计的研究人员和工程师，旨在帮助他们掌握Flyback变换器的设计方法，提升仿真的准确性和可靠性。 其他说明：提供的仿真文件可以在MATLAB 2017b及以上版本运行，建议读者按照文中步骤逐步实践，以便更好地理解和应用所学知识。
内容概要：《2024年中国城市低空经济发展指数报告》由36氪研究院发布，指出低空经济作为新质生产力的代表，已成为中国经济新的增长点。报告从发展环境、资金投入、创新能力、基础支撑和发展成效五个维度构建了综合指数评价体系，评估了全国重点城市的低空经济发展状况。北京和深圳在总指数中名列前茅，分别以91.26和84.53的得分领先，展现出强大的资金投入、创新能力和基础支撑。低空经济主要涉及无人机、eVTOL（电动垂直起降飞行器）和直升机等产品，广泛应用于农业、物流、交通、应急救援等领域。政策支持、市场需求和技术进步共同推动了低空经济的快速发展，预计到2026年市场规模将突破万亿元。 适用人群：对低空经济发展感兴趣的政策制定者、投资者、企业和研究人员。 使用场景及目标：①了解低空经济的定义、分类和发展驱动力；②掌握低空经济的主要应用场景和市场规模预测；③评估各城市在低空经济发展中的表现和潜力；④为政策制定、投资决策和企业发展提供参考依据。 其他说明：报告强调了政策监管、产业生态建设和区域融合错位的重要性，提出了加强法律法规建设、人才储备和基础设施建设等建议。低空经济正加速向网络化、智能化、规模化和集聚化方向发展，各地应找准自身比较优势，实现差异化发展。
内容概要：本文深入探讨了汇川H5U PLC程序框架，尤其是其在ETHERCAT总线控制方面的应用。该框架提供了完整的气缸控制、轴控制等功能模块，涵盖从初始化到故障处理的全过程。文中详细介绍了气缸控制的梯形图逻辑、轴控制的具体指令及其状态机设计，并展示了触摸屏与PLC变量的绑定方法。此外，还提到了三套针对不同应用场景的程序样例，包括单机设备、流水线联动和柔性生产版本。整体而言，该框架以其条理分明的代码结构和丰富的功能模块，成为自动化控制领域的有力工具。 适合人群：从事工业自动化控制系统的工程师和技术人员，特别是初学者和希望深入了解汇川H5U PLC及ETHERCAT总线控制的专业人士。 使用场景及目标：适用于需要高效、稳定的多轴运动控制和人机交互的自动化项目。主要目标是帮助用户快速掌握汇川H5U PLC的编程技巧，提高项目的开发效率和可靠性。 其他说明：文章强调了框架的实用性、易用性和详细的文档支持，使得即使是新手也能轻松上手并应用于实际项目中。
https://blog.csdn.net/qianqianaao/article/details/147515496?fromshare=blogdetail&sharetype=blogdetail&sharerId=147515496&sharerefer=PC&sharesource=qianqianaao&sharefrom=from_link python小项目
内容概要：本文详细介绍了如何利用Cruise和Simulink平台进行增程式混合动力汽车的整车仿真模型构建。主要内容涵盖增程器、电池、驱动电机等关键部件的物理参数设置，尤其是发电机和驱动电机效率MAP图的精确调整。文中强调了控制策略的重要性，将其分为驾驶模式选择、扭矩分配、SOC平衡三个子系统，并讨论了模式切换逻辑、再生制动策略以及DLL联合仿真的难点和技术细节。此外，作者分享了许多实用的经验和技巧，如使用二维插值提高增程器工作效率、设置合理的滞回区避免模式震荡、通过环形缓冲区解决时钟同步问题等。 适合人群：从事新能源汽车研究的技术人员、高校相关专业师生、对混合动力汽车仿真感兴趣的工程师。 使用场景及目标：帮助读者掌握增程式混合动力汽车仿真模型的搭建方法，提高仿真的准确性，优化控制策略，减少开发周期和成本。 其他说明：文章提供了大量实战经验和调试技巧，有助于解决实际工作中常见的问题，如模式切换不稳定、DLL编译错误、制动能量回收不合理等。同时，还分享了一些提高仿真效率的小窍门，如使用Fast Restart功能、避免内存泄漏等。
内容概要：本文详细介绍了威纶通触摸屏上利用EBpro软件和宏指令实现的经典贪吃蛇游戏。文中不仅剖析了游戏的核心逻辑，如蛇的移动、碰撞检测、方向控制以及食物生成算法，还探讨了宏指令在触摸屏编程中的具体应用。通过这个模板，读者可以深入了解宏指令的工作机制及其在工业触摸屏编程中的优势。 适合人群：对嵌入式系统、人机界面(HMI)编程感兴趣的开发者和技术爱好者。 使用场景及目标：① 学习如何在威纶通触摸屏上使用宏指令进行编程；② 掌握贪吃蛇游戏的基本逻辑和实现方法；③ 提升对工业触摸屏编程的理解，尤其是宏指令的应用技巧。 其他说明：文章提供了详细的代码片段和注释，帮助读者更好地理解和修改代码。同时，文中提到的一些优化建议（如防止180度急转弯、改进随机数生成等）有助于提高游戏性能和用户体验。
内容概要：本文详细介绍了如何利用黏菌优化算法（SMA）优化广义回归神经网络（GRNN）来进行时间序列的拟合预测建模。首先解释了SMA和GRNN的基本原理，接着提供了完整的MATLAB代码实现，包括数据加载与划分、SMA参数设置、SMA主循环、模型构建与预测、绘图与指标计算等步骤。文中不仅给出了详细的代码注释，还分享了一些实用的经验技巧，如数据处理方法、参数选择建议等。此外，通过具体的案例展示了该方法的有效性和优越性。 适合人群：对时间序列预测感兴趣的科研人员、学生以及有一定编程基础的数据分析师。 使用场景及目标：适用于需要高精度时间序列预测的应用场景，如金融、能源等领域。主要目标是提高预测精度，减少预测误差，提供可靠的预测结果。 其他说明：本文提供的代码可以直接应用于实际项目中，只需替换相应数据即可。同时，文中提到的一些经验和技巧可以帮助使用者更好地理解和应用该方法。
本书是《Data Structures and Algorithm Analysis in C++》第三版的解答手册，包含了该教科书中许多练习题的答案。这些答案反映了第三版第一次印刷时书籍的状态。特别排除了一般编程问题和任何解决方案在章节末尾有参考文献的问题。解决方案在完整性程度上有所不同；通常，细节留给读者。存在的少量代码段落应该是伪-C++代码，而不是完全完美的代码。本书适合已经学习过《Data Structures and Algorithm Analysis in C++》的学生或读者使用，作为理解和掌握数据结构与算法分析的辅助材料。
网络安全_masscan_报告转换_xls格式分析用途_1745569541.zip
少儿编程scratch项目源代码文件案例素材-JOJO奇妙冒险.zip