WoddenFish
WoddenFish

spriongboot2.0.4+shiro+redis+mybatis双数据源实现前后端分离项目之后端控制

        最近有个项目需要前后端分离开发并且设置权限，对比目前比较流行的三种权限架构（spring security 、shiro、jwt）后，由于本阶段需求没那么高，（听说spring security权限细粒度更高？？）权限的操作粒度能控制在路径及按钮上，数据粒度通过sql实现。Shrio简单够用。下面贴上整合代码：

1、pom.xml



	4.0.0

	cn.oa
	test
	0.0.1-SNAPSHOT
	jar

	test
	前后端分离shiro整合

	
		org.springframework.boot
		spring-boot-starter-parent
		2.0.4.RELEASE
		 
	

	
		UTF-8
		UTF-8
		1.8
	

	
		
		  
            org.apache.poi  
            poi  
            3.14  
          

		
		
		
		
			org.mybatis.generator
			mybatis-generator-core
			1.3.5
		
		
		
			org.json
			json
			20160810
		
		
			com.alibaba
			fastjson
			1.2.47
		
		
		
			com.alibaba
			druid
			1.1.10
		
		
			mysql
			mysql-connector-java
			runtime
		
		
		
			commons-fileupload
			commons-fileupload
			1.3.2
		
		
		
			commons-codec
			commons-codec
		
		
		
			org.apache.commons
			commons-lang3
		

		
		
			org.apache.shiro
			shiro-core
			1.4.0
		
		
			org.apache.shiro
			shiro-spring
			1.4.0
		
		
            org.springframework.boot
            spring-boot-starter-aop
        
		
		
			org.apache.shiro
			shiro-ehcache
			1.4.0
		
		
		
			org.crazycake
			shiro-redis
			2.8.24
		

		
			org.springframework.boot
			spring-boot-starter-cache
		
		
			org.springframework.boot
			spring-boot-starter-data-redis
		
		
			org.springframework.boot
			spring-boot-starter-web
		
		
			org.mybatis.spring.boot
			mybatis-spring-boot-starter
			1.3.2
		

		
			org.springframework.boot
			spring-boot-starter-test
			test
		
		
			org.springframework.boot
			spring-boot-configuration-processor
			true
		
	

	
		
			
				org.springframework.boot
				spring-boot-maven-plugin

2、application.yml

server:
  #服务端口号
  port: 8081
  tomcat:
    uri-encoding: utf-8
#spring配置
spring:
  #文件大小
  servlet:
    multipart:
      max-file-size: -1
  shiro: 
    redis: 
      host: localhost
      port: 6379
      password: 123456
      timeout: 50000
  #redis
  redis:
    # Redis服务器连接密码（默认为空） 
    host: localhost
    port: 6379
    password: 123456
    jedis:
      pool:
       # 连接池最大连接数（使用负值表示没有限制）
        max-active: 5000
       # 连接池最大阻塞等待时间（使用负值表示没有限制）   
        max-wait: -1
       # 连接池中的最大空闲连接
        max-idle: 30
       # 连接池中的最小空闲连接 
        min-idle: 5
    # 连接超时时间（毫秒）
    timeout: 50000
  #数据源一配置
  datasource-form:
    driver-class-name: com.mysql.jdbc.Driver
    jdbc-url: jdbc:mysql://localhost:3306/test1?characterEncoding=UTF-8
    username: root
    password: 123456
  #数据源二配置 
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    jdbc-url: jdbc:mysql://localhost:3306/test2
    username: root
    password: 123456
    # 初始化大小，最小，最大
    initialSize: 1
    minIdle: 3
    maxActive: 20
    # 配置获取连接等待超时的时间
    maxWait: 60000
    # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
    timeBetweenEvictionRunsMillis: 60000
    # 配置一个连接在池中最小生存的时间，单位是毫秒
    minEvictableIdleTimeMillis: 30000
    validationQuery: select 'x'
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    # 打开PSCache，并且指定每个连接上PSCache的大小
    poolPreparedStatements: true
    maxPoolPreparedStatementPerConnectionSize: 20
    # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    filters: stat,wall,slf4j
    # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
    # 合并多个DruidDataSource的监控数据
    #useGlobalDataSourceStat: true
#mybatis配置
mybatis:
  mapper-locations: classpath:mybatis/mapper/oa/*.xml,mybatis/mapper/form/*.xml
  config-location: classpath:mybatis/mybatis-config.xml
#log4j show sql
logging:
  level:
    cn.oa.mapper: debug

3、mybatis双数据源配置

        （1）数据源一：

                 datasource配置：

import javax.sql.DataSource;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class DataSourceConfig {
	
	@Bean(name="dataSourceForm")
	@ConfigurationProperties(prefix = "spring.datasource-form")
	public DataSource dataSourceForm() {
		return DataSourceBuilder.create().build();
	}
}

                配置mybatis：

package cn.oa.config;

import javax.sql.DataSource;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.mybatis.spring.SqlSessionTemplate;


@Configuration
@MapperScan(basePackages = {"cn.oa.mapper.form"},sqlSessionFactoryRef = "sqlSessionFactory2")
public class MybatisFormConfig {

	@Autowired
	@Qualifier("dataSourceForm")
	private DataSource ds2;
	
	@Bean
	public SqlSessionFactory sqlSessionFactory2() throws Exception {
		SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
		factory.setDataSource(ds2);
		factory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/form/*.xml")); //必须指定位置
		return factory.getObject();
	}
	
	@Bean
	public SqlSessionTemplate sqlSessionTemplate2() throws Exception {
		SqlSessionTemplate template = new SqlSessionTemplate(sqlSessionFactory2());
		return template;
	}
	
	@Bean(name = "transactionManager2")
    public PlatformTransactionManager transactionManager2() {
        return new DataSourceTransactionManager(ds2);
    }
}

        （2）配置数据源二：使用druid

                使用druid配置datasource：

package cn.oa.config;

import java.sql.SQLException;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import com.alibaba.druid.wall.WallConfig;
import com.alibaba.druid.wall.WallFilter;


@SuppressWarnings("all")
@Configuration
public class DruidConfig {
 
    @Value("${spring.datasource.jdbc-url}")
    private String dbUrl;
 
    @Value("${spring.datasource.username}")
    private String username;
 
    @Value("${spring.datasource.password}")
    private String password;
 
    @Value("${spring.datasource.driver-class-name}")
    private String driverClassName;
 
    @Value("${spring.datasource.initialSize}")
    private int initialSize;
 
    @Value("${spring.datasource.minIdle}")
    private int minIdle;
 
    @Value("${spring.datasource.maxActive}")
    private int maxActive;
 
    @Value("${spring.datasource.maxWait}")
    private int maxWait;
 
    @Value("${spring.datasource.timeBetweenEvictionRunsMillis}")
    private int timeBetweenEvictionRunsMillis;
 
    @Value("${spring.datasource.minEvictableIdleTimeMillis}")
    private int minEvictableIdleTimeMillis;
 
    @Value("${spring.datasource.validationQuery}")
    private String validationQuery;
 
    @Value("${spring.datasource.testWhileIdle}")
    private boolean testWhileIdle;
 
    @Value("${spring.datasource.testOnBorrow}")
    private boolean testOnBorrow;
 
    @Value("${spring.datasource.testOnReturn}")
    private boolean testOnReturn;
 
    @Value("${spring.datasource.poolPreparedStatements}")
    private boolean poolPreparedStatements;
 
    @Value("${spring.datasource.maxPoolPreparedStatementPerConnectionSize}")
    private int maxPoolPreparedStatementPerConnectionSize;
 
    @Value("${spring.datasource.filters}")
    private String filters;
 
    @Value("{spring.datasource.connectionProperties}")
    private String connectionProperties;
 
    @Bean(name="dataSourceOA",initMethod = "init", destroyMethod = "close")
    @Primary
    public DataSource dataSource() {
        DruidDataSource datasource = new DruidDataSource();
 
        datasource.setUrl(this.dbUrl);
        datasource.setUsername(username);
        datasource.setPassword(password);
        datasource.setDriverClassName(driverClassName);
 
        /** configuration */
        datasource.setInitialSize(initialSize);
        datasource.setMinIdle(minIdle);
        datasource.setMaxActive(maxActive);
        datasource.setMaxWait(maxWait);
        datasource
                .setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setValidationQuery(validationQuery);
        datasource.setTestWhileIdle(testWhileIdle);
        datasource.setTestOnBorrow(testOnBorrow);
        datasource.setTestOnReturn(testOnReturn);
        datasource.setPoolPreparedStatements(poolPreparedStatements);
        datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        try {
            datasource.setFilters(filters);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        datasource.setConnectionProperties(connectionProperties);
        return datasource;
    }
    
    @Bean
    public WallFilter wallFilter(){
        WallFilter wallFilter = new WallFilter();

        //允许执行多条SQL
        WallConfig config = new WallConfig();
        config.setMultiStatementAllow(true);
        wallFilter.setConfig(config);

        return wallFilter;
    }
 
    /**
     * 
     * http://127.0.0.1:8081/druid/login.html
     * 
     * @Title: druidServlet
     * @Description: 注册一个StatViewServlet 相当于在web.xml中声明了一个servlet
     * @param: void
     * @return: ServletRegistrationBean
     * @throws
     */
    @Bean
    public ServletRegistrationBean druidServlet() {
        ServletRegistrationBean reg = new ServletRegistrationBean();
        reg.setServlet(new StatViewServlet());
        reg.addUrlMappings("/druid/*");
        /** 白名单 */
        reg.addInitParameter("allow", "127.0.0.1");
        /** IP黑名单(共同存在时，deny优先于allow) */
        // reg.addInitParameter("deny", "192.168.2.105");
        /** /druid/login.html登录时账号密码 */
        reg.addInitParameter("loginUsername", "root");
        reg.addInitParameter("loginPassword", "root");
        /** 是否能够重置数据 禁用HTML页面上的“Reset All”功能 */
        reg.addInitParameter("resetEnable", "false");
        return reg;
    }
 
    /**
     * 注册一个：filterRegistrationBean 相当于在web.xml中声明了一个Filter
     */
    @Bean
    public FilterRegistrationBean druidStatFilter() {
        FilterRegistrationBean druidStatFilter = new FilterRegistrationBean();
        druidStatFilter.setFilter(new WebStatFilter());
        /** 添加过滤规则. */
        druidStatFilter.addUrlPatterns("/*");
        /** 监控选项滤器 */
        druidStatFilter.addInitParameter("DruidWebStatFilter", "/*");
        /** 添加不需要忽略的格式信息. */
        druidStatFilter.addInitParameter("exclusions",
                "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        /** 配置profileEnable能够监控单个url调用的sql列表 */
        druidStatFilter.addInitParameter("profileEnable", "true");
        /** 当前的cookie的用户 */
        druidStatFilter.addInitParameter("principalCookieName", "USER_COOKIE");
        /** 当前的session的用户 */
        druidStatFilter
                .addInitParameter("principalSessionName", "USER_SESSION");
        return druidStatFilter;
    }
}

                mybatis配置：

package cn.oa.config;

import javax.sql.DataSource;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import cn.oa.utils.ArrayUtils;

@Configuration
@MapperScan(basePackages = {"cn.oa.mapper.oa.custom","cn.oa.mapper.oa"},sqlSessionFactoryRef = "sqlSessionFactory1")
public class MybatisOAConfig {

	@Autowired
	@Qualifier("dataSourceOA")
	private DataSource ds1;
	
	@Bean
	public SqlSessionFactory sqlSessionFactory1() throws Exception {
		SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
		factory.setDataSource(ds1);
		//使用两个mapper位置，办法是组合两个resource数组
		Resource[] res = new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/oa/*.xml");
		Resource[] resCustom = new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/oa/custom/*.xml");
		factory.setMapperLocations(ArrayUtils.connectResource(res, resCustom));
		
		return factory.getObject();
	}
	
	@Bean
	public SqlSessionTemplate sqlSessionTemplate1() throws Exception {
		SqlSessionTemplate template = new SqlSessionTemplate(sqlSessionFactory1());
		return template;
	}
	
}

4、shiro配置：

        （1）自定义realm

package cn.oa.utils.shiro;

import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.LockedAccountException;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;

import cn.oa.pojo.Auth;
import cn.oa.pojo.Role;
import cn.oa.pojo.User;
import cn.oa.service.AuthService;


public class AuthRealm extends AuthorizingRealm {
	@Autowired
	private AuthService authService;

	// 认证.登录
	@Override
	protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        //获取用户的输入的账号.
        String username = (String) token.getPrincipal();
        //通过username从数据库中查找 User对象，如果找到，没找到.
        //实际项目中，这里可以根据实际情况做缓存，如果不做，Shiro自己也是有时间间隔机制，2分钟内不会重复执行该方法
        User user = authService.getUser(username);
        if (user == null) {
            return null;
        }
        if (user.getStatus() == 2) { //账户冻结
            throw new LockedAccountException();
        }
		return new SimpleAuthenticationInfo(user, // 用户名
				user.getPassword(), // 密码
				this.getClass().getName());
	}

	// 授权
	@Override
	protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principal) {
		SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
		User user = (User) principal.getPrimaryPrincipal();
		Role role = authService.getRole(user.getRoleId());
		if (role != null) {
			authorizationInfo.addRole(role.getRolename());
			if (role.getAuths() != null && role.getAuths().size() > 0) {
				for (Auth auth : role.getAuths()) {
					authorizationInfo.addStringPermission(auth.getAuthPermission());
				}
			}
		}
		return authorizationInfo;
	}

}

        （2）自定义密码校验器：

package cn.oa.utils.shiro;

import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authc.credential.SimpleCredentialsMatcher;
import org.apache.shiro.crypto.hash.Md5Hash;


public class CredentialsMatcher extends SimpleCredentialsMatcher{

    @Override
    public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {
        UsernamePasswordToken utoken=(UsernamePasswordToken) token;
        //获得用户输入的密码:(可以采用加盐(salt)的方式去检验)
        String inPassword = new String(utoken.getPassword());
        /**oa加盐，md5散列两次*/
        Md5Hash md5Hash=new Md5Hash(inPassword,"test",2);
        //获得数据库中的密码
        String dbPassword=(String) info.getCredentials();
        //进行密码的比对
        return this.equals(md5Hash.toString(), dbPassword);
    }
    
}

        （3）重点：因为是前后端分离，所以要将sessionId存储以后返回给前端，所以重写sessionId获取方法

package cn.oa.utils.shiro;

import org.apache.shiro.web.servlet.ShiroHttpServletRequest;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.apache.shiro.web.util.WebUtils;
import org.springframework.util.StringUtils;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.Serializable;
 

public class MySessionManager extends DefaultWebSessionManager {
 
    private static final String AUTHORIZATION = "token";
 
    private static final String REFERENCED_SESSION_ID_SOURCE = "Stateless request";
 
    public MySessionManager() {
        super();
    }
 
    @Override
    protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
        String id = WebUtils.toHttp(request).getHeader(AUTHORIZATION);
        //如果请求头中有 Authorization 则其值为sessionId
        if (!StringUtils.isEmpty(id)) {
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, REFERENCED_SESSION_ID_SOURCE);
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, id);
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
            return id;
        } else {
            //否则按默认规则从cookie取sessionId
            return super.getSessionId(request, response);
        }
    }
}

        （4）全局异常处理自定义：

package cn.oa.utils.shiro;
 
import com.alibaba.fastjson.support.spring.FastJsonJsonView;
import org.apache.shiro.authz.UnauthenticatedException;
import org.apache.shiro.authz.UnauthorizedException;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;
 
public class MyExceptionHandler implements HandlerExceptionResolver {
 
	@Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception ex) {
        ModelAndView mv = new ModelAndView();
        FastJsonJsonView view = new FastJsonJsonView();
        Map attributes = new HashMap(5);
        if (ex instanceof UnauthenticatedException) {
            attributes.put("code", "400");
            attributes.put("msg", "token错误");
        } else if (ex instanceof UnauthorizedException) {
            attributes.put("code", "403");
            attributes.put("msg", "用户无权限");
        } else {
            attributes.put("code", "500");
            attributes.put("msg", ex.getMessage());
        }
        view.setAttributesMap(attributes);
        mv.setView(view);
        return mv;
    }
}

        （5）最后的核心：shiro权限过滤器及其相关配置：

package cn.oa.config;
 
import java.util.LinkedHashMap;
import java.util.Map;

import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.session.mgt.SessionManager;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.crazycake.shiro.RedisCacheManager;
import org.crazycake.shiro.RedisManager;
import org.crazycake.shiro.RedisSessionDAO;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.HandlerExceptionResolver;

import cn.oa.utils.shiro.AuthRealm;
import cn.oa.utils.shiro.CredentialsMatcher;
import cn.oa.utils.shiro.MyExceptionHandler;
import cn.oa.utils.shiro.MySessionManager;
 
@Configuration
public class ShiroConfig {
 
	@Value("${spring.shiro.redis.host}")
    private String host;
    @Value("${spring.shiro.redis.port}")
    private int port;
    @Value("${spring.shiro.redis.timeout}")
    private int timeout;
    @Value("${spring.shiro.redis.password}")
    private String password;
    
    @Bean("shiroFilter")
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
 
        /*Map filterChainDefinitionMap = new LinkedHashMap();
        //注意过滤器配置顺序 不能颠倒
        //配置退出 过滤器,其中的具体的退出代码Shiro已经替我们实现了，登出后跳转配置的loginUrl
        filterChainDefinitionMap.put("/logout", "logout");
        // 配置不会被拦截的链接 顺序判断
        filterChainDefinitionMap.put("/static/**", "anon");
        filterChainDefinitionMap.put("/druid/**", "anon");
        filterChainDefinitionMap.put("/login", "anon");
        filterChainDefinitionMap.put("/**", "authc");
        //配置shiro默认登录界面地址，前后端分离中登录界面跳转应由前端路由控制，后台仅返回json数据
        shiroFilterFactoryBean.setLoginUrl("/unauth");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);*/
        return shiroFilterFactoryBean;
    }
 
    
    //配置自定义的权限登录器
    @Bean(name="authRealm")
    public AuthRealm authRealm(@Qualifier("credentialsMatcher") CredentialsMatcher matcher) {
        AuthRealm authRealm=new AuthRealm();
        authRealm.setCredentialsMatcher(matcher);
        return authRealm;
    }
    //配置自定义的密码比较器
    @Bean(name="credentialsMatcher")
    public CredentialsMatcher credentialsMatcher() {
        return new CredentialsMatcher();
    }
 
    /**
     * 配置安全管理器   
     */
    @Bean
    public SecurityManager securityManager(@Qualifier("authRealm") AuthRealm authRealm) {
    	DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(authRealm);
        // 自定义session管理 使用redis
        securityManager.setSessionManager(sessionManager());
        // 自定义缓存实现 使用redis
        securityManager.setCacheManager(cacheManager());
        return securityManager;
    }
    
    //自定义sessionManager
    @Bean
    public SessionManager sessionManager() {
        MySessionManager mySessionManager = new MySessionManager();
        mySessionManager.setSessionDAO(redisSessionDAO());
        //不在地址栏显示sessionId
        mySessionManager.setSessionIdUrlRewritingEnabled(false);
        mySessionManager.setSessionValidationSchedulerEnabled(true);
        return mySessionManager;
    }
 
    /**
     * 配置shiro redisManager
     * 

     * 使用的是shiro-redis开源插件
     *
     * @return
     */
    public RedisManager redisManager() {
        RedisManager redisManager = new RedisManager();
        redisManager.setHost(host);
        redisManager.setPort(port);
        redisManager.setExpire(1800);// 配置缓存过期时间(30分钟)
        redisManager.setTimeout(timeout);
        redisManager.setPassword(password);
        return redisManager;
    }
 
    /**
     * cacheManager 缓存 redis实现
     * 

     * 使用的是shiro-redis开源插件
     *
     * @return
     */
    @Bean
    public RedisCacheManager cacheManager() {
        RedisCacheManager redisCacheManager = new RedisCacheManager();
        redisCacheManager.setRedisManager(redisManager());
        return redisCacheManager;
    }
 
    /**
     * RedisSessionDAO shiro sessionDao层的实现 通过redis
     * 

     * 使用的是shiro-redis开源插件
     */
    @Bean
    public RedisSessionDAO redisSessionDAO() {
        RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
        redisSessionDAO.setRedisManager(redisManager());
        return redisSessionDAO;
    }
    
    
    
    /*@Bean("lifecycleBeanPostProcessor")
    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }*/
    /**
     *  开启Shiro的注解(如@RequiresRoles,@RequiresPermissions),需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证
     * 配置以下两个bean(DefaultAdvisorAutoProxyCreator和AuthorizationAttributeSourceAdvisor)即可实现此功能
     * @return
     */
    @Bean
    public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator(){
        DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        advisorAutoProxyCreator.setProxyTargetClass(true);
        return advisorAutoProxyCreator;
    }
    /**
     * 开启shiro aop注解支持.
     * 使用代理方式;所以需要开启代码支持;
     *
     * @param securityManager
     * @return
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }
 
    /**
     * 注册全局异常处理
     * @return
     */
    @Bean(name = "exceptionHandler")
    public HandlerExceptionResolver handlerExceptionResolver() {
        return (HandlerExceptionResolver) new MyExceptionHandler();
    }

}

5、redis配置：

package cn.oa.config;

import java.time.Duration;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import redis.clients.jedis.JedisPoolConfig;

@Configuration
public class RedisConfig {
	
	@Value("${spring.redis.port}")
	private int port;
	@Value("${spring.redis.host}")
	private String host;
	@Value("${spring.redis.jedis.pool.max-active}")
	private int maxActive;
	@Value("${spring.redis.timeout}")  
    private int timeout; 
    @Value("${spring.redis.jedis.pool.max-idle}")  
    private int maxIdle;  
    @Value("${spring.redis.jedis.pool.min-idle}")  
    private int minIdle;  
    @Value("${spring.redis.jedis.pool.max-wait}")  
    private long maxWaitMillis;
    @Value("${spring.redis.password}")
    private String password;

    
    /**  
    * @author gaodeqiang
    * @Description redis连接池 
    * @date 2018年8月16日上午9:41:12
    */
    @Bean
    public JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        // 最大空闲数
        jedisPoolConfig.setMaxIdle(maxIdle);
        // 连接池的最大数据库连接数
        jedisPoolConfig.setMaxTotal(maxActive);
        // 最大建立连接等待时间
        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
        jedisPoolConfig.setMinIdle(minIdle);
        return jedisPoolConfig;
    }
   
    /**  
    * @Description 单机版配置 
    * @date 2018年8月16日上午9:41:01
    */
    @Bean
    public JedisConnectionFactory JedisConnectionFactory(JedisPoolConfig jedisPoolConfig){
    	RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration ();
        redisStandaloneConfiguration.setHostName(host);
        redisStandaloneConfiguration.setPort(port);
        redisStandaloneConfiguration.setPassword(RedisPassword.of(password));

        JedisClientConfiguration.JedisClientConfigurationBuilder jedisClientConfiguration = JedisClientConfiguration.builder();
        jedisClientConfiguration.connectTimeout(Duration.ofMillis(timeout));//  connection timeout

        JedisConnectionFactory factory = new JedisConnectionFactory(redisStandaloneConfiguration,
                jedisClientConfiguration.build());
        return factory;
 
    }

    
    /**  
    * @Description 实例化redisTemplate对象 
    * @date 2018年8月16日上午9:41:37
    */
    @Bean
    public RedisTemplate functionDomainRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate redisTemplate = new RedisTemplate<>();
        initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
        return redisTemplate;
    }
    
    /**  
    * @Description 设置数据存入 redis 的序列化方式,并开启事务 
    * @date 2018年8月16日上午9:42:06
    */
    private void initDomainRedisTemplate(RedisTemplate redisTemplate, RedisConnectionFactory factory) {
        //如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！  
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        // 开启事务
        redisTemplate.setEnableTransactionSupport(true);
        redisTemplate.setConnectionFactory(factory);
    }
    
    
   /* *//**  
    * @Description 注入封装RedisTemplate 
    * @date 2018年8月17日下午2:50:58
    *//*
    @Bean(name = "redisUtils")
    public RedisUtils redisUtil(RedisTemplate redisTemplate) {
        RedisUtils redisUtil = new RedisUtils();
        redisUtil.setRedisTemplate(redisTemplate);
        return redisUtil;
    }*/
    
}

封装redis工具类使用：（直接autowired注入RedisUtils即可）

package cn.oa.utils;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

@Service
public class RedisUtils {

	@Autowired
	private RedisTemplate redisTemplate;


	// =============================common============================
	/**
	 * 指定缓存失效时间
	 * 
	 * @param key
	 *            键
	 * @param time
	 *            时间(秒)
	 * @return
	 */
	public boolean expire(String key, long time) {
		try {
			if (time > 0) {
				redisTemplate.expire(key, time, TimeUnit.SECONDS);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 根据key 获取过期时间
	 * 
	 * @param key
	 *            键 不能为null
	 * @return 时间(秒) 返回0代表为永久有效
	 */
	public long getExpire(String key) {
		return redisTemplate.getExpire(key, TimeUnit.SECONDS);
	}

	/**
	 * 判断key是否存在
	 * 
	 * @param key
	 *            键
	 * @return true 存在 false不存在
	 */
	public boolean hasKey(String key) {
		try {
			return redisTemplate.hasKey(key);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 删除缓存
	 * 
	 * @param key
	 *            可以传一个值 或多个
	 */
	@SuppressWarnings("unchecked")
	public void del(String... key) {
		if (key != null && key.length > 0) {
			if (key.length == 1) {
				redisTemplate.delete(key[0]);
			} else {
				redisTemplate.delete(CollectionUtils.arrayToList(key));
			}
		}
	}

	// ============================String=============================
	/**
	 * 普通缓存获取
	 * 
	 * @param key
	 *            键
	 * @return 值
	 */
	public Object get(String key) {
		return key == null ? null : redisTemplate.opsForValue().get(key);
	}

	/**
	 * 普通缓存放入
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @return true成功 false失败
	 */
	public boolean set(String key, Object value) {
		try {
			redisTemplate.opsForValue().set(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}

	}

	/**
	 * 普通缓存放入并设置时间
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @param time
	 *            时间(秒) time要大于0 如果time小于等于0 将设置无限期
	 * @return true成功 false 失败
	 */
	public boolean set(String key, Object value, long time) {
		try {
			if (time > 0) {
				redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
			} else {
				set(key, value);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 递增
	 * 
	 * @param key
	 *            键
	 * @param by
	 *            要增加几(大于0)
	 * @return
	 */
	public long incr(String key, long delta) {
		if (delta < 0) {
			throw new RuntimeException("递增因子必须大于0");
		}
		return redisTemplate.opsForValue().increment(key, delta);
	}

	/**
	 * 递减
	 * 
	 * @param key
	 *            键
	 * @param by
	 *            要减少几(小于0)
	 * @return
	 */
	public long decr(String key, long delta) {
		if (delta < 0) {
			throw new RuntimeException("递减因子必须大于0");
		}
		return redisTemplate.opsForValue().increment(key, -delta);
	}

	// ================================Map=================================
	/**
	 * HashGet
	 * 
	 * @param key
	 *            键 不能为null
	 * @param item
	 *            项 不能为null
	 * @return 值
	 */
	public Object hget(String key, String item) {
		return redisTemplate.opsForHash().get(key, item);
	}

	/**
	 * 获取hashKey对应的所有键值
	 * 
	 * @param key
	 *            键
	 * @return 对应的多个键值
	 */
	public Map hmget(String key) {
		return redisTemplate.opsForHash().entries(key);
	}

	/**
	 * HashSet
	 * 
	 * @param key
	 *            键
	 * @param map
	 *            对应多个键值
	 * @return true 成功 false 失败
	 */
	public boolean hmset(String key, Map map) {
		try {
			redisTemplate.opsForHash().putAll(key, map);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * HashSet 并设置时间
	 * 
	 * @param key
	 *            键
	 * @param map
	 *            对应多个键值
	 * @param time
	 *            时间(秒)
	 * @return true成功 false失败
	 */
	public boolean hmset(String key, Map map, long time) {
		try {
			redisTemplate.opsForHash().putAll(key, map);
			if (time > 0) {
				expire(key, time);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 向一张hash表中放入数据,如果不存在将创建
	 * 
	 * @param key
	 *            键
	 * @param item
	 *            项
	 * @param value
	 *            值
	 * @return true 成功 false失败
	 */
	public boolean hset(String key, String item, Object value) {
		try {
			redisTemplate.opsForHash().put(key, item, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 向一张hash表中放入数据,如果不存在将创建
	 * 
	 * @param key
	 *            键
	 * @param item
	 *            项
	 * @param value
	 *            值
	 * @param time
	 *            时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
	 * @return true 成功 false失败
	 */
	public boolean hset(String key, String item, Object value, long time) {
		try {
			redisTemplate.opsForHash().put(key, item, value);
			if (time > 0) {
				expire(key, time);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 删除hash表中的值
	 * 
	 * @param key
	 *            键 不能为null
	 * @param item
	 *            项 可以使多个 不能为null
	 */
	public void hdel(String key, Object... item) {
		redisTemplate.opsForHash().delete(key, item);
	}

	/**
	 * 判断hash表中是否有该项的值
	 * 
	 * @param key
	 *            键 不能为null
	 * @param item
	 *            项 不能为null
	 * @return true 存在 false不存在
	 */
	public boolean hHasKey(String key, String item) {
		return redisTemplate.opsForHash().hasKey(key, item);
	}

	/**
	 * hash递增 如果不存在,就会创建一个 并把新增后的值返回
	 * 
	 * @param key
	 *            键
	 * @param item
	 *            项
	 * @param by
	 *            要增加几(大于0)
	 * @return
	 */
	public double hincr(String key, String item, double by) {
		return redisTemplate.opsForHash().increment(key, item, by);
	}

	/**
	 * hash递减
	 * 
	 * @param key
	 *            键
	 * @param item
	 *            项
	 * @param by
	 *            要减少记(小于0)
	 * @return
	 */
	public double hdecr(String key, String item, double by) {
		return redisTemplate.opsForHash().increment(key, item, -by);
	}

	// ============================set=============================
	/**
	 * 根据key获取Set中的所有值
	 * 
	 * @param key
	 *            键
	 * @return
	 */
	public Set sGet(String key) {
		try {
			return redisTemplate.opsForSet().members(key);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 根据value从一个set中查询,是否存在
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @return true 存在 false不存在
	 */
	public boolean sHasKey(String key, Object value) {
		try {
			return redisTemplate.opsForSet().isMember(key, value);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将数据放入set缓存
	 * 
	 * @param key
	 *            键
	 * @param values
	 *            值 可以是多个
	 * @return 成功个数
	 */
	public long sSet(String key, Object... values) {
		try {
			return redisTemplate.opsForSet().add(key, values);
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 将set数据放入缓存
	 * 
	 * @param key
	 *            键
	 * @param time
	 *            时间(秒)
	 * @param values
	 *            值 可以是多个
	 * @return 成功个数
	 */
	public long sSetAndTime(String key, long time, Object... values) {
		try {
			Long count = redisTemplate.opsForSet().add(key, values);
			if (time > 0) {
				expire(key, time);
			}
			return count;
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 获取set缓存的长度
	 * 
	 * @param key
	 *            键
	 * @return
	 */
	public long sGetSetSize(String key) {
		try {
			return redisTemplate.opsForSet().size(key);
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 移除值为value的
	 * 
	 * @param key
	 *            键
	 * @param values
	 *            值 可以是多个
	 * @return 移除的个数
	 */
	public long setRemove(String key, Object... values) {
		try {
			Long count = redisTemplate.opsForSet().remove(key, values);
			return count;
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}
	// ===============================list=================================

	/**
	 * 获取list缓存的内容
	 * 
	 * @param key
	 *            键
	 * @param start
	 *            开始
	 * @param end
	 *            结束 0 到 -1代表所有值
	 * @return
	 */
	public List lGet(String key, long start, long end) {
		try {
			return redisTemplate.opsForList().range(key, start, end);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 获取list缓存的长度
	 * 
	 * @param key
	 *            键
	 * @return
	 */
	public long lGetListSize(String key) {
		try {
			return redisTemplate.opsForList().size(key);
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 通过索引 获取list中的值
	 * 
	 * @param key
	 *            键
	 * @param index
	 *            索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
	 * @return
	 */
	public Object lGetIndex(String key, long index) {
		try {
			return redisTemplate.opsForList().index(key, index);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 将list放入缓存
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @param time
	 *            时间(秒)
	 * @return
	 */
	public boolean lSet(String key, Object value) {
		try {
			redisTemplate.opsForList().rightPush(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将list放入缓存
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @param time
	 *            时间(秒)
	 * @return
	 */
	public boolean lSet(String key, Object value, long time) {
		try {
			redisTemplate.opsForList().rightPush(key, value);
			if (time > 0) {
				expire(key, time);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将list放入缓存
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @param time
	 *            时间(秒)
	 * @return
	 */
	public boolean lSet(String key, List value) {
		try {
			redisTemplate.opsForList().rightPushAll(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将list放入缓存
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @param time
	 *            时间(秒)
	 * @return
	 */
	public boolean lSet(String key, List value, long time) {
		try {
			redisTemplate.opsForList().rightPushAll(key, value);
			if (time > 0) {
				expire(key, time);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 根据索引修改list中的某条数据
	 * 
	 * @param key
	 *            键
	 * @param index
	 *            索引
	 * @param value
	 *            值
	 * @return
	 */
	public boolean lUpdateIndex(String key, long index, Object value) {
		try {
			redisTemplate.opsForList().set(key, index, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 移除N个值为value
	 * 
	 * @param key
	 *            键
	 * @param count
	 *            移除多少个
	 * @param value
	 *            值
	 * @return 移除的个数
	 */
	public long lRemove(String key, long count, Object value) {
		try {
			Long remove = redisTemplate.opsForList().remove(key, count, value);
			return remove;
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}
}
 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java项目级组件)

        

            

                
    
                    
  • x86-64汇编语言训练程序与实战
                        十除以十等于一

                        
    本文还有配套的精品资源，点击获取简介：汇编语言是一种低级语言，与机器代码紧密相关，特别适用于编写系统级代码及性能要求高的应用。nasm编译器是针对x86和x86-64架构的汇编语言编译器，支持多种语法风格和指令集。项目Euler提供数学和计算机科学问题，鼓励编程技巧应用，前100个问题的答案可共享。x86-64架构扩展了寄存器数量并引入新指令，提升了数据处理效率。学习汇编语言能够深入理解计算机底层
    
                    
    • 
                    
  • 移动端城市区县二级联动选择功能实现包
                        good2know

                        
    本文还有配套的精品资源，点击获取简介：本项目是一套为移动端设计的jQuery实现方案，用于简化用户在选择城市和区县时的流程。它包括所有必需文件：HTML、JavaScript、CSS及图片资源。通过动态更新下拉菜单选项，实现城市到区县的联动效果，支持数据异步加载。开发者可以轻松集成此功能到移动网站或应用，并可基于需求进行扩展和优化。1.jQuery移动端解决方案概述jQuery技术简介jQuery
    
                    
    • 
                    
  • （二）SAP Group Reporting (GR) 核心子模块功能及数据流向架构解析
                        

                        
    数据如何从子公司流转到合并报表的全过程，即数据采集→合并引擎→报表输出，特别是HANA内存计算如何优化传统ETL瓶颈。SAPGroupReporting(GR)核心模块功能及数据流向的架构解析，涵盖核心组件、数据处理流程和关键集成点，适用于S/4HANA1809+版本：一、核心功能模块概览模块功能关键事务码/FioriApp数据采集(DataCollection)整合子公司财务数据（SAP/非SA
    
                    
    • 
                    
  • 实时数据流计算引擎Flink和Spark剖析
                        程小舰
flinkspark数据库kafkahadoop
                        
    在过去几年，业界的主流流计算引擎大多采用SparkStreaming，随着近两年Flink的快速发展，Flink的使用也越来越广泛。与此同时，Spark针对SparkStreaming的不足，也继而推出了新的流计算组件。本文旨在深入分析不同的流计算引擎的内在机制和功能特点，为流处理场景的选型提供参考。（DLab数据实验室w.x.公众号出品）一.SparkStreamingSparkStreamin
    
                    
    • 
                    
  • 深入解析JVM工作原理：从字节码到机器指令的全过程
                        

                        
    一、JVM概述Java虚拟机(JVM)是Java平台的核心组件，它实现了Java"一次编写，到处运行"的理念。JVM是一个抽象的计算机器，它有自己的指令集和运行时内存管理机制。JVM的主要职责：加载：读取.class文件并验证其正确性存储：管理内存分配和垃圾回收执行：解释或编译字节码为机器指令安全：提供沙箱环境限制恶意代码二、JVM架构详解JVM由三个主要子系统组成：1.类加载子系统类加载过程分为
    
                    
    • 
                    
  • 2019-06-05
                        第十七把巴鲁克

                        
    今天去实验田里实习，见到了福寿螺真的可怕且牛皮，六级也快来了，说实话还是害怕。我昨天考了环工原理，真的太难了，太烦了，理工科真的难，烦。实验报告还是没写，要抓紧速度抓紧时间，还是应该学会努力学习，远离一些不上进的事物。
    
                    
    • 
                    
  • 【C++算法】76.优先级队列_前 K 个高频单词
                        流星白龙
优选算法C++c++算法开发语言
                        
    文章目录题目链接：题目描述：解法C++算法代码：题目链接：692.前K个高频单词题目描述：解法利用堆来解决TopK问题预处理一下原始的字符串数组，用一个哈希表统计一下每一个单词出现的频次。创建一个大小为k的堆频次：小根堆字典序（频次相同的时候）：大根堆循环让元素依次进堆判断提取结果C++算法代码：classSolution{//定义类型别名，PSI表示对typedefpairPSI;//自定义比较
    
                    
    • 
                    
  • Flowable 实战落地核心：选型决策与坑点破解
                        练习时长两年半的程序员小胡
Flowable流程引擎实战指南低代码BPMN流程引擎flowable后端java
                        
    在企业级流程引擎的落地过程中，选型的准确性和坑点的预见性直接决定项目成败。本文聚焦Flowable实战中最关键的“选型决策”与“常见坑点”，结合真实项目经验，提供可落地的解决方案。一、流程引擎选型：从业务本质出发1.1选型的三大核心维度企业在选择流程引擎时，需避免陷入“技术崇拜”，应回归业务本质。评估Flowable是否适用，可从三个维度判断：业务复杂度若流程涉及动态审批链（如按金额自动升级审批）
    
                    
    • 
                    
  • Flowable 高级扩展：自定义元素与性能优化实战
                        练习时长两年半的程序员小胡
Flowable流程引擎实战指南流程图flowableBPMN流程引擎java
                        
    在前五篇文章中，我们从基础概念、流程设计、API实战、SpringBoot集成，到外部系统协同，逐步构建了Flowable的应用体系。但企业级复杂场景中，原生功能往往难以满足定制化需求——比如需要特殊的审批规则网关、与决策引擎联动实现动态路由，或是在高并发场景下优化流程引擎性能。本文将聚焦Flowable的高级扩展能力，详解如何自定义流程元素、集成规则引擎，并掌握大型系统中的性能调优策略。一、自定
    
                    
    • 
                    
  • 企业级区块链平台Hyperchain核心原理剖析
                        boyedu
区块链区块链企业级区块链平台Hyperchain
                        
    Hyperchain作为国产自主可控的企业级联盟区块链平台，其核心原理围绕高性能共识、隐私保护、智能合约引擎及可扩展架构展开，通过多模块协同实现企业级区块链网络的高效部署与安全运行。以下从核心架构、关键技术、性能优化、安全机制、应用场景五个维度展开剖析：一、核心架构：分层解耦与模块化设计Hyperchain采用分层架构，将区块链功能解耦为独立模块，支持灵活组合与扩展：P2P网络层由验证节点（VP）
    
                    
    • 
                    
  • JAVA接口机结构解析
                        秃狼
SpringBoot八股文Javajava学习
                        
    什么是接口机在Java项目中，接口机通常指用于与外部系统进行数据交互的中间层，负责处理请求和响应的转换、协议适配、数据格式转换等任务。接口机的结构我们的接口机的结构分为两个大部分，外部接口机和内部接口机，在业务的调度上也是通过mq来实现的，只要的目的就是为了解耦合和做差异化。在接口机中主要的方法就是定时任务，消息的发送和消费，其他平台调用接口机只能提供外部接口机的方法进行调用，外部接口机可以提供消
    
                    
    • 
                    
  • 编程算法：技术创新的引擎与业务增长的核心驱动力
                        

                        
    在数字经济时代，算法已成为推动技术创新与业务增长的隐形引擎。从存内计算突破冯·诺依曼瓶颈，到动态规划优化万亿级金融交易，编程算法正在重塑产业竞争格局。一、存内计算：突破冯·诺依曼瓶颈的算法革命1.1存内计算的基本原理传统计算架构中90%的能耗消耗在数据搬运上。存内计算（Processing-in-Memory）通过直接在存储单元执行计算，实现能效10-100倍提升：#传统计算vs存内计算能耗模型i
    
                    
    • 
                    
  • 【项目实战】 容错机制与故障恢复：保障系统连续性的核心体系
                        本本本添哥
004-研效与DevOps运维工具链002-进阶开发能力分布式
                        
    在分布式系统中，硬件故障、网络波动、软件异常等问题难以避免。容错机制与故障恢复的核心目标是：通过主动检测故障、自动隔离风险、快速转移负载、重建数据一致性，最大限度减少故障对业务的影响，保障系统“持续可用”与“数据不丢失”。以下从核心机制、实现方式、典型案例等维度展开说明。一、故障检测：及时发现异常节点故障检测是容错的第一步，需通过多维度手段实时感知系统组件状态，确保故障被快速识别。1.健康检查与心
    
                    
    • 
                    
  • 刻意忽视孩子的成功，会让孩子迷失存在价值
                        草原野狼战队

                        
    2020年5月22日星期五晴亲子日记2014级7班马驰翔爸爸893苏珊·福沃德在《中毒的父母》一书中提到：小孩子不会区分事实和笑话，他们会相信父母说的有关自己的话，并将其变为自己的观点。中国式的父母总是习惯用对比式的教育方式去“刺激”孩子，过分关注别人家的孩子，这种看似微不足道的习惯，却给孩子的未来造成着巨大的影响，其中最严重的一点就是用生命去证明自己存在的价值。在我身边有一个非常鲜活却让人痛心的
    
                    
    • 
                    
  • Java并发核心：线程池使用技巧与最佳实践！ | 多线程篇(五)
                        bug菌¹
Java实战(进阶版)javaJava零基础入门Java并发线程池多线程篇
                        
    本文收录于「Java进阶实战」专栏，专业攻坚指数级提升，希望能够助你一臂之力，帮你早日登顶实现财富自由；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！环境说明：Windows10+IntelliJIDEA2021.3.2+Jdk1.8本文目录前言摘要正文何为线程池？为什么需要线程池？线程池的好处线程池使用场景如何创建线程池？线程池的常见配置源码解析案例分享案例代码演示案例运行
    
                    
    • 
                    
  • 5G基站信号加速器！AD8021ARZ-REEL7亚德诺 超低噪声高速电压放大器 专利失真消除技术!
                        深圳市尚想信息技术有限公司
5G通信高速运放ADI黑科技8K视频医疗超声
                        
    AD8021ARZ-REEL7ADI：重新定义高速放大器的性能极限！一、产品简介AD8021ARZ-REEL7是ADI（亚德诺半导体）推出的超低噪声高速电压反馈放大器，采用XFCB工艺和专利失真消除技术，专为4K/8K视频处理、医疗成像、5G通信等超高频应用设计。以1.8GHz带宽和0.1nV/√Hz超低噪声，成为高速信号调理的终极解决方案！二、五大颠覆性优势军工级信号保真度1.8GHz-3dB带
    
                    
    • 
                    
  • Redis + Caffeine 实现高效的两级缓存架构
                        周童學
Java缓存redis架构
                        
    Redis+Caffeine实现高效的两级缓存架构引言在现代高并发系统中，缓存是提升系统性能的关键组件之一。传统的单一缓存方案往往难以同时满足高性能和高可用性的需求。本文将介绍如何结合Redis和Caffeine构建一个高效的两级缓存系统，并通过三个版本的演进展示如何逐步优化代码结构。项目源代码：github地址、gitee地址两级缓存架构概述两级缓存通常由本地缓存（如Caffeine）和分布式缓
    
                    
    • 
                    
  • 【Coze搞钱实战】3. 避坑指南：对话流设计中的6个致命错误（真实案例）
                        AI_DL_CODE
Coze平台对话流设计客服Bot避坑用户流失封号风险智能客服配置故障修复指南
                        
    摘要：对话流设计是智能客服Bot能否落地的核心环节，直接影响用户体验与业务安全。本文基于50+企业Bot部署故障分析，聚焦导致用户流失、投诉甚至封号的6大致命错误：无限循环追问、人工移交超时、敏感词过滤缺失、知识库冲突、未处理否定意图、跨平台适配失败。通过真实案例拆解每个错误的表现形式、技术根因及工业级解决方案，提供可直接复用的Coze配置代码、工作流模板和检测工具。文中包含对话流健康度检测工具使
    
                    
    • 
                    
  • 语文教学反思 ——一单元测试
                        一抹_绿茶香

                        
    我喜欢上语文课，现在最开心的时刻也就是课上那45分钟了。它可以让我和孩子们骑上骏马驰骋在知识的草原上，可以让我们乘着巨轮在书籍的海洋里任意航行……周三举行了一单元测试，今晚一单元的所有内容暂时告一段落。对于这单元我有如下思考：本单元的主题词是“读书”，几篇课文都是围绕着读书来编排的。里面有讲读书乐趣的，讲读书方法的，还有孩子们第一次接触的访谈录等。微笑班级从一年级下学期就开始阅读“闲书”，所以教学
    
                    
    • 
                    
  • Deepseek技术深化：驱动大数据时代颠覆性变革的未来引擎
                        荣华富贵8
springboot搜索引擎后端缓存redis
                        
    在大数据时代，信息爆炸和数据驱动的决策逐渐重塑各行各业。作为一项前沿技术，Deepseek正在引领新一轮技术革新，颠覆传统数据处理与分析方式。本文将从理论原理、应用场景和前沿代码实践三个层面，深入剖析Deepseek技术如何为大数据时代提供颠覆性变革的解决方案。一、技术背景与核心思想1.1大数据挑战与机遇在数据量呈指数级增长的背景下，传统数据处理方法面临数据存储、计算效率和信息提取精度的诸多挑战。
    
                    
    • 
                    
  • 分布式链路追踪系统架构设计：从理论到企业级实践
                        ma451152002
java分布式系统架构
                        
    分布式链路追踪系统架构设计：从理论到企业级实践本文深入探讨分布式链路追踪系统的架构设计原理、关键技术实现和企业级应用实践，为P7架构师提供完整的技术方案参考。目录引言：分布式链路追踪的重要性核心概念与技术原理系统架构设计数据模型与协议标准核心组件架构设计性能优化与扩展性设计企业级实施策略技术选型与对比分析监控与运维体系未来发展趋势P7架构师面试要点引言：分布式链路追踪的重要性微服务架构下的挑战在现
    
                    
    • 
                    
  • 2019-04-05
                        诚信装饰祝希信

                        
    2019年4月5日星期五天气晴(451)六年级七班祝全文今天是清明节，都放假了，好多人外出游玩踏青。一大早醒来去提水浇菜园子，全文还在呼呼睡大觉，浇完菜园子，简单吃了点饭就去干活了。中午回到家，厨房里乱七八糟，全文自己的脏衣服也没有洗，心里感觉真不是滋味，怎么会这样？优秀的孩子不是这样的，是我不该发脾气吗？还是回家继续忙碌，他人爱怎么怎么？家庭是共同的家庭，应该都有责任去承担，不要整天说来说去。全
    
                    
    • 
                    
  • Android Slices：让应用功能在系统级交互中触手可及
                        安卓开发者
AndroidJetpackandroid交互gitee
                        
    引言在当今移动应用生态中，用户每天要面对数十个甚至上百个应用的选择，如何让自己的应用在关键时刻触达用户，成为开发者面临的重要挑战。Google在Android9Pie中引入的Slices技术，正是为了解决这一痛点而生。本文将全面介绍AndroidSlices的概念、实现方法、应用场景以及最佳实践，帮助开发者掌握这一提升用户参与度的强大工具。什么是AndroidSlices？AndroidSlice
    
                    
    • 
                    
  • 重温古诗词
                        茉茉

                        
    今天，陪着着女儿又从一年级开始背古诗了，一边读，一边给她讲解着其中的含意，一些也是我们小时候学过的，不管时光怎么流逝，这些文学作品都还依然经典。小的时候不理解，基本都是死记硬背的。现在再回头看看这些作品，理解和感受真的完全不一样了！人类的智慧把文字的魅力展现的淋漓尽致。正所谓“无声”胜“有声”。
    
                    
    • 
                    
  • vue element 封装表单
                        影子信息
vuevue.jsjavascript前端
                        
    背景：在前端系统开发中，系统页面涉及到的表单组件比较多，所以进行了简单的封装。封装的包括一些Form表单组件，如下：input输入框、select下拉框、等实现效果：理论知识：表单组件官方链接：点击跳转封装组件：封装组件的思路：不封装element组件，每一个input组件绑定一个form对象，例如官网。简单封装element组件，利用for循环生成form表单的每一项el-form-item。进
    
                    
    • 
                    
  • 【大模型微调实战】4. P-Tuning爆款文案生成：让模型学会小红书“爽感”写作，转化率提升300%
                        AI_DL_CODE
大模型微调P-Tuning小红书文案爆款生成情绪强化自然语言生成提示工程
                        
    摘要：在内容营销竞争白热化的当下，普通文案已难以突破流量壁垒。本文聚焦P-Tuning技术在小红书爆款文案生成中的落地应用，通过参数化提示向量优化，将抽象的“爽感”写作转化为可量化、可训练的技术指标。文中提出“六步成文法”，从情绪化数据集构建到爆款元素复刻，完整拆解如何用RTX3060级显卡实现0.1%参数量微调，使文案点击率从2.1%提升至8.7%，爆文率提高5倍，单条文案带货超8万元。核心创新
    
                    
    • 
                    
  • Spark SQL架构及高级用法
                        Aurora_NeAr
sparksql架构
                        
    SparkSQL架构概述架构核心组件API层（用户接口）输入方式：SQL查询；DataFrame/DatasetAPI。统一性：所有接口最终转换为逻辑计划树（LogicalPlan），进入优化流程。编译器层（Catalyst优化器）核心引擎：基于规则的优化器（Rule-BasedOptimizer,RBO）与成本优化器（Cost-BasedOptimizer,CBO）。处理流程：阶段输入输出关键动
    
                    
    • 
                    
  • 二级域名分发系统商业版全开源v3版
                        CloseAi论坛
程序源码二级域名分发系统商业版开源
                        
    介绍：名分发-快乐二级域名分发源码主要是二级域名分发网站源码，域名接口配置自己研究吧网盘下载地址：https://zijiewangpan.com/NbX6950sYLn图片：
    
                    
    • 
                    
  • 二级域名分发网站源码 商业版全开源
                        lskelasi
程序源码二级域名分发源码二级域名分发网站源码源码
                        
    介绍：快乐二级域名分发-快乐二级域名分发源码主要是二级域名分发网站源码，不懂的不要下载了。本套源码可设置收费使用，有充值接口，域名接口配置自己研究吧网盘下载地址：https://zijiewangpan.com/jsX0JAuRE01图片：
    
                    
    • 
                    
  • 最新二级域名分发系统网站源码 可商用
                        huihuixxx
程序源码小鬼授权系统源码全解密源码授权代码二级域名分发系统网站源码
                        
    介绍：1.源码楼主网上买的没有后门是旧版本2.支付接口调用的是码支付来进行的3.支付接口需要登陆管理员后台安装4.支付接口必须信息正确只能装一次5.在线充值默认的充值比例是1：1【搭建教程】1.把源码上传主机并解压2.绑定根目录和域名并解析3.访问你的域名即可提示安装4.后台登陆地址：你的域名/admin5.登陆后台安装你的支付接口（需要的话）6.码支付怎么使用方法百度一下！网盘下载地址：http
    
                    
    • 
                                
  • Spring4.1新特性——Spring MVC增强
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • mysql 性能查询优化
                                    annan211
javasql优化mysql应用服务器
                                    
    

1 时间到底花在哪了？
  mysql在执行查询的时候需要执行一系列的子任务，这些子任务包含了整个查询周期最重要的阶段，这其中包含了大量为了
  检索数据列到存储引擎的调用以及调用后的数据处理，包括排序、分组等。在完成这些任务的时候，查询需要在不同的地方
  花费时间，包括网络、cpu计算、生成统计信息和执行计划、锁等待等。尤其是向底层存储引擎检索数据的调用操作。这些调用需要在内存操
    
                                
    • 
                                
  • windows系统配置
                                    cherishLC
windows
                                    
    删除Hiberfil.sys ：使用命令powercfg -h off 关闭休眠功能即可： 
http://jingyan.baidu.com/article/f3ad7d0fc0992e09c2345b51.html 
类似的还有pagefile.sys 
 
msconfig 配置启动项 
shutdown 定时关机 
 
ipconfig 查看网络配置 
ipconfig /flushdns
    
                                
    • 
                                
  • 人体的排毒时间
                                    Array_06
工作
                                    
    ======================== 
||  人体的排毒时间是什么时候？|| 
========================  
 
转载于： 
http://zhidao.baidu.com/link?url=ibaGlicVslAQhVdWWVevU4TMjhiKaNBWCpZ1NS6igCQ78EkNJZFsEjCjl3T5EdXU9SaPg04bh8MbY1bR
    
                                
    • 
                                
  • ZooKeeper
                                    cugfy
zookeeper
                                    
    Zookeeper是一个高性能，分布式的，开源分布式应用协调服务。它提供了简单原始的功能，分布式应用可以基于它实现更高级的服务，比如同步， 配置管理，集群管理，名空间。它被设计为易于编程，使用文件系统目录树作为数据模型。服务端跑在java上，提供java和C的客户端API。 Zookeeper是Google的Chubby一个开源的实现，是高有效和可靠的协同工作系统，Zookeeper能够用来lea
    
                                
    • 
                                
  • 网络爬虫的乱码处理
                                    随意而生
爬虫网络
                                    
    下边简单总结下关于网络爬虫的乱码处理。注意，这里不仅是中文乱码，还包括一些如日文、韩文 、俄文、藏文之类的乱码处理，因为他们的解决方式 是一致的，故在此统一说明。     网络爬虫，有两种选择，一是选择nutch、hetriex，二是自写爬虫，两者在处理乱码时，原理是一致的，但前者处理乱码时，要看懂源码后进行修改才可以，所以要废劲一些；而后者更自由方便，可以在编码处理
    
                                
    • 
                                
  • Xcode常用快捷键
                                    张亚雄
xcode
                                    
    一、总结的常用命令： 
 
    隐藏xcode command+h 
 
    退出xcode command+q 
 
    关闭窗口 command+w 
 
    关闭所有窗口 command+option+w 
 
    关闭当前
    
                                
    • 
                                
  • mongoDB索引操作
                                    adminjun
mongodb索引
                                    
    一、索引基础：    MongoDB的索引几乎与传统的关系型数据库一模一样，这其中也包括一些基本的优化技巧。下面是创建索引的命令：    > db.test.ensureIndex({"username":1})    可以通过下面的名称查看索引是否已经成功建立： &nbs
    
                                
    • 
                                
  • 成都软件园实习那些话
                                    aijuans
成都 软件园 实习
                                    
    无聊之中，翻了一下日志，发现上一篇经历是很久以前的事了，悔过~~ 
　　断断续续离开了学校快一年了，习惯了那里一天天的幼稚、成长的环境，到这里有点与世隔绝的感觉。不过还好，那是刚到这里时的想法，现在感觉在这挺好，不管怎么样，最要感谢的还是老师能给这么好的一次催化成长的机会，在这里确实看到了好多好多能想到或想不到的东西。 
　　都说在外面和学校相比最明显的差距就是与人相处比较困难，因为在外面每个人都
    
                                
    • 
                                
  • Linux下FTP服务器安装及配置
                                    ayaoxinchao
linuxFTP服务器vsftp
                                    
    检测是否安装了FTP 
[root@localhost ~]# rpm -q vsftpd 
如果未安装：package vsftpd is not installed  安装了则显示：vsftpd-2.0.5-28.el5累死的版本信息 
  
安装FTP 
运行yum install vsftpd命令，如[root@localhost ~]# yum install vsf
    
                                
    • 
                                
  • 使用mongo-java-driver获取文档id和查找文档
                                    BigBird2012
driver
                                    
    注：本文所有代码都使用的mongo-java-driver实现。 
  
在MongoDB中，一个集合（collection）在概念上就类似我们SQL数据库中的表（Table），这个集合包含了一系列文档（document）。一个DBObject对象表示我们想添加到集合（collection）中的一个文档（document），MongoDB会自动为我们创建的每个文档添加一个id，这个id在
    
                                
    • 
                                
  • JSONObject以及json串
                                    bijian1013
jsonJSONObject
                                    
    一.JAR包简介 
    要使程序可以运行必须引入JSON-lib包，JSON-lib包同时依赖于以下的JAR包： 
    1.commons-lang-2.0.jar 
    2.commons-beanutils-1.7.0.jar 
    3.commons-collections-3.1.jar 
&n
    
                                
    • 
                                
  • [Zookeeper学习笔记之三]Zookeeper实例创建和会话建立的异步特性
                                    bit1129
zookeeper
                                    
    为了说明问题，看个简单的代码， 
  
    import org.apache.zookeeper.*;  
      
    import java.io.IOException;  
    import java.util.concurrent.CountDownLatch;  
    import java.util.concurrent.ThreadLocal
    
                                
    • 
                                
  • 【Scala十二】Scala核心六：Trait
                                    bit1129
scala
                                    
    Traits are a fundamental unit of code reuse in Scala. A trait encapsulates method and field definitions, which can then be reused by mixing them into classes. Unlike class inheritance, in which each c
    
                                
    • 
                                
  • weblogic version 10.3破解
                                    ronin47
weblogic
                                    
    版本：WebLogic Server 10.3 
 
说明：%DOMAIN_HOME%：指WebLogic Server 域(Domain）目录 
例如我的做测试的域的根目录 DOMAIN_HOME=D:/Weblogic/Middleware/user_projects/domains/base_domain 
 
1.为了保证操作安全，备份%DOMAIN_HOME%/security/Defa
    
                                
    • 
                                
  • 求第n个斐波那契数
                                    BrokenDreams

                                    
            今天看到群友发的一个问题：写一个小程序打印第n个斐波那契数。 
        自己试了下，搞了好久。。。基础要加强了。 
        
  &nbs
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-访问者模式-Visitor
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 


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

interface IVisitor {
	
	//第二次分派，Visitor调用Element
	void visitConcret
    
                                
    • 
                                
  • MatConvNet的excise 3改为网络配置文件形式
                                    cherishLC
matlab
                                    
    MatConvNet为vlFeat作者写的matlab下的卷积神经网络工具包，可以使用GPU。 
主页：
http://www.vlfeat.org/matconvnet/ 
教程：
http://www.robots.ox.ac.uk/~vgg/practicals/cnn/index.html 
 
注意：需要下载新版的MatConvNet替换掉教程中工具包中的matconvnet：
http
    
                                
    • 
                                
  • ZK Timeout再讨论
                                    chenchao051
zookeepertimeouthbase
                                    
    http://crazyjvm.iteye.com/blog/1693757 文中提到相关超时问题，但是又出现了一个问题，我把min和max都设置成了180000，但是仍然出现了以下的异常信息： 
Client session timed out, have not heard from server in 154339ms for sessionid 0x13a3f7732340003
    
                                
    • 
                                
  • CASE WHEN 用法介绍
                                    daizj
sqlgroup bycase when
                                    
    CASE WHEN 用法介绍 
 
1. CASE WHEN 表达式有两种形式 
 
 
--简单Case函数  
 
CASE sex  
WHEN '1' THEN '男'  
WHEN '2' THEN '女'  
ELSE '其他' END  
 
--Case搜索函数  
 
CASE 
WHEN sex = '1' THEN 
    
                                
    • 
                                
  • PHP技巧汇总:提高PHP性能的53个技巧
                                    dcj3sjt126com
PHP
                                    
    PHP技巧汇总:提高PHP性能的53个技巧　　用单引号代替双引号来包含字符串，这样做会更快一些。因为PHP会在双引号包围的字符串中搜寻变量，　　单引号则不会，注意：只有echo能这么做，它是一种可以把多个字符串当作参数的函数译注：　　PHP手册中说echo是语言结构，不是真正的函数，故把函数加上了双引号)。　　1、如果能将类的方法定义成static，就尽量定义成static，它的速度会提升将近4倍
    
                                
    • 
                                
  • Yii框架中CGridView的使用方法以及详细示例
                                    dcj3sjt126com
yii
                                    
    CGridView显示一个数据项的列表中的一个表。 
表中的每一行代表一个数据项的数据,和一个列通常代表一个属性的物品(一些列可能对应于复杂的表达式的属性或静态文本)。　　CGridView既支持排序和分页的数据项。排序和分页可以在AJAX模式或正常的页面请求。使用CGridView的一个好处是,当用户浏览器禁用JavaScript,排序和分页自动退化普通页面请求和仍然正常运行。 
实例代码如下：
    
                                
    • 
                                
  • Maven项目打包成可执行Jar文件
                                    dyy_gusi
assembly
                                    
    Maven项目打包成可执行Jar文件 
在使用Maven完成项目以后，如果是需要打包成可执行的Jar文件，我们通过eclipse的导出很麻烦，还得指定入口文件的位置，还得说明依赖的jar包，既然都使用Maven了，很重要的一个目的就是让这些繁琐的操作简单。我们可以通过插件完成这项工作，使用assembly插件。具体使用方式如下： 
1、在项目中加入插件的依赖： 
<plugin>
	
    
                                
    • 
                                
  • php常见错误
                                    geeksun
PHP
                                    
    1.  kevent() reported that connect() failed (61: Connection refused) while connecting to upstream, client: 127.0.0.1, server: localhost, request: "GET / HTTP/1.1", upstream: "fastc
    
                                
    • 
                                
  • 修改linux的用户名
                                    hongtoushizi
linuxchange password
                                    
    Change Linux Username 
更改Linux用户名，需要修改4个系统的文件： 
/etc/passwd 
/etc/shadow 
/etc/group 
/etc/gshadow 
古老/传统的方法是使用vi去直接修改，但是这有安全隐患（具体可自己搜一下），所以后来改成使用这些命令去代替： 
vipw 
vipw -s 
vigr 
vigr -s 
  
具体的操作顺
    
                                
    • 
                                
  • 第五章 常用Lua开发库1-redis、mysql、http客户端
                                    jinnianshilongnian
nginxlua
                                    
    对于开发来说需要有好的生态开发库来辅助我们快速开发，而Lua中也有大多数我们需要的第三方开发库如Redis、Memcached、Mysql、Http客户端、JSON、模板引擎等。 
一些常见的Lua库可以在github上搜索，https://github.com/search?utf8=%E2%9C%93&q=lua+resty。 
  Redis客户端 
lua-resty-r
    
                                
    • 
                                
  • zkClient 监控机制实现
                                    liyonghui160com
zkClient 监控机制实现
                                    
      
       直接使用zk的api实现业务功能比较繁琐。因为要处理session loss，session expire等异常，在发生这些异常后进行重连。又因为ZK的watcher是一次性的，如果要基于wather实现发布/订阅模式，还要自己包装一下，将一次性订阅包装成持久订阅。另外如果要使用抽象级别更高的功能，比如分布式锁，leader选举
    
                                
    • 
                                
  • 在Mysql 众多表中查找一个表名或者字段名的 SQL 语句
                                    pda158
mysql
                                    
    在Mysql 众多表中查找一个表名或者字段名的 SQL 语句：   
　　方法一：SELECT table_name, column_name from information_schema.columns WHERE column_name LIKE 'Name';
　　方法二：SELECT column_name from information_schema.colum
    
                                
    • 
                                
  • 程序员对英语的依赖
                                    Smile.zeng
英语程序猿
                                    
    1、程序员最基本的技能，至少要能写得出代码，当我们还在为建立类的时候思考用什么单词发牢骚的时候，英语与别人的差距就直接表现出来咯。 
2、程序员最起码能认识开发工具里的英语单词，不然怎么知道使用这些开发工具。 
3、进阶一点，就是能读懂别人的代码，有利于我们学习人家的思路和技术。 
4、写的程序至少能有一定的可读性，至少要人别人能懂吧... 
 
以上一些问题，充分说明了英语对程序猿的重要性。骚年
    
                                
    • 
                                
  • Oracle学习笔记(8) 使用PLSQL编写触发器
                                    vipbooks
oraclesql编程活动Access
                                    
        时间过得真快啊，转眼就到了Oracle学习笔记的最后个章节了，通过前面七章的学习大家应该对Oracle编程有了一定了了解了吧，这东东如果一段时间不用很快就会忘记了，所以我会把自己学习过的东西做好详细的笔记，用到的时候可以随时查找，马上上手！希望这些笔记能对大家有些帮助！ 
    这是第八章的学习笔记，学习完第七章的子程序和包之后
    
                                
    •