骑鹤下江南
骑鹤下江南

springboot security+redis+jwt+验证码 登录验证

概述

　　基于jwt的token认证方案

springboot security+redis+jwt+验证码 登录验证_第1张图片

 验证码

　　框架的搭建，可以自己根据网上搭建，或者看我博客springboot相关的博客，这边就不做介绍了。验证码生成可以利用Java第三方组件，引入

       
            com.github.penggle
            kaptcha
            2.3.2

配置验证码相关的属性

@Component
public class KaptchaConfig
{
    @Bean
    public DefaultKaptcha getDefaultKaptcha()
    {
        DefaultKaptcha defaultKaptcha = new DefaultKaptcha();
        Properties properties = new Properties();
        /*是否使用边框*/
        properties.setProperty("kaptcha.border","no");
        /*验证码 边框颜色*/
        //properties.setProperty("kaptcha.border.color","black");
        /*验证码干扰线 颜色*/
        properties.setProperty("kaptcha.noise.color","black");
        /*验证码宽度*/
        properties.setProperty("kaptcha.image.width","110");
        /*验证码高度*/
        properties.setProperty("kaptcha.image.height","40");
        //properties.setProperty("kaptcha.session.key","code");
        /*验证码颜色*/
        properties.setProperty("kaptcha.textproducer.font.color","204,128,255");
        /*验证码大小*/
        properties.setProperty("kaptcha.textproducer.font.size","30");
        properties.setProperty("kaptcha.textproducer.char.space","3");
        /*验证码字数*/
        properties.setProperty("kaptcha.textproducer.char.length","4");
        /*验证码 背景渐变色 开始*/
        properties.setProperty("kaptcha.background.clear.from","240,240,240");
        /*验证码渐变色 结束*/
        properties.setProperty("kaptcha.background.clear.to","240,240,240");
        /*验证码字体*/
        properties.setProperty("kaptcha.textproducer.font.names", "Arial,微软雅黑");
        Config config = new Config(properties);
        defaultKaptcha.setConfig(config);
        return defaultKaptcha;
    }
}

配置相应的配置接口就能生成验证码，但是这钟样式有点不好看，如果自定义还非常麻烦，索性

 

 利用网上大佬写好的工具类（链接不见了，找到在加上）

import javax.imageio.ImageIO;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.LinearGradientPaint;
import java.awt.Paint;
import java.awt.RenderingHints;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Random;

/**
 * 
 * Description:验证码工具类
 * @author huangweicheng
 * @date 2019/10/23   
*/ 
public class VerifyCodeUtils
{
    //使用到Algerian字体，系统里没有的话需要安装字体，字体只显示大写，去掉了1,0,i,o几个容易混淆的字符
    public static final String VERIFY_CODES = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
    private static Random random = new Random();


    /**
     * 使用系统默认字符源生成验证码
     * @param verifySize    验证码长度
     * @return
     */
    public static String generateVerifyCode(int verifySize){
        return generateVerifyCode(verifySize, VERIFY_CODES);
    }
    /**
     * 使用指定源生成验证码
     * @param verifySize    验证码长度
     * @param sources    验证码字符源
     * @return
     */
    public static String generateVerifyCode(int verifySize, String sources){
        if(sources == null || sources.length() == 0){
            sources = VERIFY_CODES;
        }
        int codesLen = sources.length();
        Random rand = new Random(System.currentTimeMillis());
        StringBuilder verifyCode = new StringBuilder(verifySize);
        for(int i = 0; i < verifySize; i++){
            verifyCode.append(sources.charAt(rand.nextInt(codesLen-1)));
        }
        return verifyCode.toString();
    }

    /**
     * 生成随机验证码文件,并返回验证码值
     * @param w
     * @param h
     * @param outputFile
     * @param verifySize
     * @return
     * @throws IOException
     */
    public static String outputVerifyImage(int w, int h, File outputFile, int verifySize) throws IOException{
        String verifyCode = generateVerifyCode(verifySize);
        outputImage(w, h, outputFile, verifyCode);
        return verifyCode;
    }

    /**
     * 输出随机验证码图片流,并返回验证码值
     * @param w
     * @param h
     * @param os
     * @param verifySize
     * @return
     * @throws IOException
     */
    public static String outputVerifyImage(int w, int h, OutputStream os, int verifySize) throws IOException{
        String verifyCode = generateVerifyCode(verifySize);
        outputImage(w, h, os, verifyCode);
        return verifyCode;
    }

    /**
     * 生成指定验证码图像文件
     * @param w
     * @param h
     * @param outputFile
     * @param code
     * @throws IOException
     */
    public static void outputImage(int w, int h, File outputFile, String code) throws IOException{
        if(outputFile == null){
            return;
        }
        File dir = outputFile.getParentFile();
        if(!dir.exists()){
            dir.mkdirs();
        }
        try{
            outputFile.createNewFile();
            FileOutputStream fos = new FileOutputStream(outputFile);
            outputImage(w, h, fos, code);
            fos.close();
        } catch(IOException e){
            throw e;
        }
    }

    /**
     * 输出指定验证码图片流
     * @param w
     * @param h
     * @param os
     * @param code
     * @throws IOException
     */
    public static void outputImage(int w, int h, OutputStream os, String code) throws IOException{
        int verifySize = code.length();
        BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
        Random rand = new Random();
        Graphics2D g2 = image.createGraphics();
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
        Color[] colors = new Color[5];
        Color[] colorSpaces = new Color[] { Color.WHITE, Color.CYAN,
                Color.GRAY, Color.LIGHT_GRAY, Color.MAGENTA, Color.ORANGE,
                Color.PINK, Color.YELLOW };
        float[] fractions = new float[colors.length];
        for(int i = 0; i < colors.length; i++){
            colors[i] = colorSpaces[rand.nextInt(colorSpaces.length)];
            fractions[i] = rand.nextFloat();
        }
        Arrays.sort(fractions);

        g2.setColor(Color.GRAY);// 设置边框色
        g2.fillRect(0, 0, w, h);

        Color c = getRandColor(200, 250);
        g2.setColor(c);// 设置背景色
        g2.fillRect(0, 2, w, h-4);

        //绘制干扰线
        Random random = new Random();
        g2.setColor(getRandColor(160, 200));// 设置线条的颜色
        for (int i = 0; i < 20; i++) {
            int x = random.nextInt(w - 1);
            int y = random.nextInt(h - 1);
            int xl = random.nextInt(6) + 1;
            int yl = random.nextInt(12) + 1;
            g2.drawLine(x, y, x + xl + 40, y + yl + 20);
        }

        // 添加噪点
        float yawpRate = 0.05f;// 噪声率
        int area = (int) (yawpRate * w * h);
        for (int i = 0; i < area; i++) {
            int x = random.nextInt(w);
            int y = random.nextInt(h);
            int rgb = getRandomIntColor();
            image.setRGB(x, y, rgb);
        }

        shear(g2, w, h, c);// 使图片扭曲

        g2.setColor(getRandColor(100, 160));
        int fontSize = h-4;
        Font font = new Font("Algerian", Font.ITALIC, fontSize);
        g2.setFont(font);
        char[] chars = code.toCharArray();
        for(int i = 0; i < verifySize; i++){
            AffineTransform affine = new AffineTransform();
            affine.setToRotation(Math.PI / 4 * rand.nextDouble() * (rand.nextBoolean() ? 1 : -1), (w / verifySize) * i + fontSize/2, h/2);
            g2.setTransform(affine);
            g2.drawChars(chars, i, 1, ((w-10) / verifySize) * i + 5, h/2 + fontSize/2 - 10);
        }

        g2.dispose();
        ImageIO.write(image, "jpg", os);
    }

    private static Color getRandColor(int fc, int bc) {
        if (fc > 255)
            fc = 255;
        if (bc > 255)
            bc = 255;
        int r = fc + random.nextInt(bc - fc);
        int g = fc + random.nextInt(bc - fc);
        int b = fc + random.nextInt(bc - fc);
        return new Color(r, g, b);
    }

    private static int getRandomIntColor() {
        int[] rgb = getRandomRgb();
        int color = 0;
        for (int c : rgb) {
            color = color << 8;
            color = color | c;
        }
        return color;
    }

    private static int[] getRandomRgb() {
        int[] rgb = new int[3];
        for (int i = 0; i < 3; i++) {
            rgb[i] = random.nextInt(255);
        }
        return rgb;
    }

    private static void shear(Graphics g, int w1, int h1, Color color) {
        shearX(g, w1, h1, color);
        shearY(g, w1, h1, color);
    }

    private static void shearX(Graphics g, int w1, int h1, Color color) {

        int period = random.nextInt(2);

        boolean borderGap = true;
        int frames = 1;
        int phase = random.nextInt(2);

        for (int i = 0; i < h1; i++) {
            double d = (double) (period >> 1)
                    * Math.sin((double) i / (double) period
                    + (6.2831853071795862D * (double) phase)
                    / (double) frames);
            g.copyArea(0, i, w1, 1, (int) d, 0);
            if (borderGap) {
                g.setColor(color);
                g.drawLine((int) d, i, 0, i);
                g.drawLine((int) d + w1, i, w1, i);
            }
        }

    }

    private static void shearY(Graphics g, int w1, int h1, Color color) {

        int period = random.nextInt(40) + 10; // 50;

        boolean borderGap = true;
        int frames = 20;
        int phase = 7;
        for (int i = 0; i < w1; i++) {
            double d = (double) (period >> 1)
                    * Math.sin((double) i / (double) period
                    + (6.2831853071795862D * (double) phase)
                    / (double) frames);
            g.copyArea(i, 0, 1, h1, 0, (int) d);
            if (borderGap) {
                g.setColor(color);
                g.drawLine(i, (int) d, i, 0);
                g.drawLine(i, (int) d + h1, i, h1);
            }

        }

    }
    public static void main(String[] args) throws IOException
    {
        String verifyCode = generateVerifyCode(4);
        System.out.println(verifyCode);
    }
}

将生成的验证码放置到redis里，登录时候，从cookie取值，过滤器拦截验证（仅限PC端）

import com.google.code.kaptcha.impl.DefaultKaptcha;import io.swagger.annotations.ApiOperation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

/**
 * 
 * Description:用户相关接口
 * @author huangweicheng
 * @date 2019/10/22   
*/ 
@RestController
@RequestMapping("/user")
public class UserController
{
    private static final Logger log = LoggerFactory.getLogger(UserController.class);

    @Autowired
    private RedisTemplate redisTemplate;

    @RequestMapping("/verifyCode.jpg")
    @ApiOperation(value = "图片验证码")
    public void verifyCode(HttpServletRequest request, HttpServletResponse response) throws IOException
    {
        /*禁止缓存*/
        response.setDateHeader("Expires",0);
        response.setHeader("Cache-Control", "no-store, no-cache, must-revalidate");
        response.addHeader("Cache-Control", "post-check=0, pre-check=0");
        response.setHeader("Pragma", "no-cache");
        response.setContentType("image/jpeg");
        /*获取验证码*/
        String code = VerifyCodeUtils.generateVerifyCode(4);
        /*验证码已key，value的形式缓存到redis 存放时间一分钟*/
        log.info("验证码============>" + code);
        String uuid = UUID.randomUUID().toString();
        redisTemplate.opsForValue().set(uuid,code,1,TimeUnit.MINUTES);
        Cookie cookie = new Cookie("captcha",uuid);
        /*key写入cookie，验证时获取*/
        response.addCookie(cookie);
        ServletOutputStream outputStream = response.getOutputStream();
        //ImageIO.write(bufferedImage,"jpg",outputStream);
        VerifyCodeUtils.outputImage(110,40,outputStream,code);
        outputStream.flush();
        outputStream.close();
    }
}

尝试访问接口，生成的验证码是不是比组件生成的验证码好看多了。

验证码过滤器

验证码生成后，哪些地方需要用到验证码，配置对应的路径，设置过滤器进行过滤，过滤器继承OncePerRequestFilter，这样能够确保在一次请求只通过一Filter，而不需要重复执行，对应的路径没有正确的验证码抛出一个自定义的异常进行统一处理。

import com.alibaba.fastjson.JSONObject;import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashSet;
import java.util.Set;

/**
 * 
 * Description: 图片验证码过滤器
 * @author huangweicheng
 * @date 2019/10/22   
*/
@Component
public class ImageCodeFilter extends OncePerRequestFilter implements InitializingBean
{
    /**
     * 哪些地址需要图片验证码进行验证
    */ 
    private Set urls = new HashSet<>();

    private AntPathMatcher antPathMatcher = new AntPathMatcher();

    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    public void afterPropertiesSet() throws ServletException
    {
        super.afterPropertiesSet();
        urls.add("/hwc/user/login");
    }

    @Override
    protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException
    {
        httpServletResponse.setContentType("application/json;charset=utf-8");
        boolean action = false;
        String t = httpServletRequest.getRequestURI();
        for (String url : urls)
        {
            if (antPathMatcher.match(url,httpServletRequest.getRequestURI()))
            {
                action = true;
                break;
            }
        }
        if (action)
        {
            try {
                /*图片验证码是否正确*/
                checkImageCode(httpServletRequest);
            }catch (ImageCodeException e){
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("code", ResultModel.ERROR);
                jsonObject.put("msg",e.getMessage());
                httpServletResponse.getWriter().write(jsonObject.toJSONString());
                return;
            }
        }
        filterChain.doFilter(httpServletRequest,httpServletResponse);
    }
    /** 
     * 
     * Description:验证图片验证码是否正确
     * @param httpServletRequest
     * @author huangweicheng
     * @date 2019/10/22   
    */ 
    private void checkImageCode(HttpServletRequest httpServletRequest)
    {
        /*从cookie取值*/
        Cookie[] cookies = httpServletRequest.getCookies();
        String uuid = "";
        for (Cookie cookie : cookies)
        {
            String cookieName = cookie.getName();
            if ("captcha".equals(cookieName))
            {
                uuid = cookie.getValue();
            }
        }
        String redisImageCode = (String) redisTemplate.opsForValue().get(uuid);
        /*获取图片验证码与redis验证*/
        String imageCode = httpServletRequest.getParameter("imageCode");
        /*redis的验证码不能为空*/
        if (StringUtils.isEmpty(redisImageCode) || StringUtils.isEmpty(imageCode))
        {
            throw new ImageCodeException("验证码不能为空");
        }
        /*校验验证码*/
        if (!imageCode.equalsIgnoreCase(redisImageCode))
        {
            throw new ImageCodeException("验证码错误");
        }
        redisTemplate.delete(redisImageCode);
    }
}

 自定义的验证码异常

import lombok.Data;

import java.io.Serializable;
/** 
 * 
 * Description:图片验证码相关异常
 * @author huangweicheng
 * @date 2019/10/22   
*/
@Data
public class ImageCodeException extends RuntimeException implements Serializable
{
    private static final long serialVersionUID = 4554L;

    private String code;

    public ImageCodeException()
    {
    }

    public ImageCodeException(String message)
    {
        super(message);
    }

    public ImageCodeException(String code,String message)
    {
        super(message);
        this.code = code;
    }

    public ImageCodeException(String message,Throwable cause)
    {
        super(message,cause);
    }

    public ImageCodeException(Throwable cause)
    {
        super(cause);
    }

    public ImageCodeException(String message,Throwable cause,boolean enableSupperssion,boolean writablesStackTrace)
    {
        super(message,cause,enableSupperssion,writablesStackTrace);
    }

}

过滤器统一处理

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * 
 * Description:全局变量捕获
 * @author huangweicheng
 * @date 2019/10/22   
*/
@ControllerAdvice
public class GlobalExceptionHandler
{
    @ResponseBody
    @ExceptionHandler(Exception.class)
    public ResponseEntity exceptionHandler(Exception e)
    {
        e.printStackTrace();
        ResultModel resultModel = new ResultModel(2,"系统出小差了，让网站管理员来处理吧 ಥ_ಥ");
        return new ResponseEntity<>(resultModel, HttpStatus.OK);
    }

    @ResponseBody
    @ExceptionHandler(ImageCodeException.class)
    public ResponseEntity exceptionHandler(ImageCodeException e)
    {
        e.printStackTrace();
        ResultModel resultModel = new ResultModel(2,e.getMessage());
        return new ResponseEntity<>(resultModel,HttpStatus.OK);
    }
}

说了这么多，只是我们token验证的开始

security

引入spring的security安全框架

　　　　 
            org.springframework.boot
            spring-boot-starter-security

最终的安全配置

import com.alibaba.fastjson.JSONObject;import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.security.NoSuchAlgorithmException;
import java.security.Security;
import java.util.concurrent.TimeUnit;


/**
 * 
 * Description:安全配置
 * @author huangweicheng
 * @date 2019/10/21   
*/ 
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter
{
    /**
     * 日志记录
     */
    private static final Logger log = LoggerFactory.getLogger(Security.class);

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    protected SysUserDetailsServiceImpl sysUserDetailsService;

    @Autowired
    private ImageCodeFilter imageCodeFilter;

    @Autowired
    private JwtTokenUtil jwtTokenUtil;
    /**
     * 
     * Description:资源角色配置登录
     * @param http
     * @author huangweicheng
     * @date 2019/10/21   
    */
    @Override
    protected void configure(HttpSecurity http) throws Exception
    {
        /*图片验证码过滤器设置在密码验证之前*/
        http.addFilterBefore(imageCodeFilter, UsernamePasswordAuthenticationFilter.class)
                .authorizeRequests()
                .antMatchers(HttpMethod.GET, "/", "/*.html", "favicon.ico", "/**/*.html", "/**/*.html", "/**/*.css", "/**/*.js").permitAll()
                .antMatchers("/user/**","/login").permitAll()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/hwc/**").hasRole("USER")
                .anyRequest().authenticated()
                .and().formLogin().loginProcessingUrl("/user/login")
                /*自定义登录成功处理，返回token值*/
                .successHandler((HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication)->
                {
                    log.info("用户为====>" + httpServletRequest.getParameter("username") + "登录成功");
                    httpServletResponse.setContentType("application/json;charset=utf-8");
                    /*获取用户权限信息*/
                    UserDetails userDetails = (UserDetails) authentication.getPrincipal();
                    String token = jwtTokenUtil.generateToken(userDetails);
                    /*存储redis并设置了过期时间*/
                    redisTemplate.boundValueOps(userDetails.getUsername() + "hwc").set(token,10, TimeUnit.MINUTES);
                    JSONObject jsonObject = new JSONObject();
                    jsonObject.put("code", ResultModel.SUCCESS);
                    jsonObject.put("msg","登录成功");
                    /*认证信息写入header*/
                    httpServletResponse.setHeader("Authorization",token);
                    httpServletResponse.getWriter().write(jsonObject.toJSONString());
                })
                /*登录失败处理*/
                .failureHandler((HttpServletRequest request, HttpServletResponse response, AuthenticationException exception)->
                {
                    log.info("用户为====>" + request.getParameter("username") + "登录失败");
                    String content = exception.getMessage();
                    //TODO 后期改进密码错误方式，统一处理
                    String temp = "Bad credentials";
                    if (temp.equals(exception.getMessage()))
                    {
                        content = "用户名或密码错误";
                    }
                    response.setContentType("application/json;charset=utf-8");
                    JSONObject jsonObject = new JSONObject();
                    jsonObject.put("code", ResultModel.ERROR);
                    jsonObject.put("msg",content);
                    jsonObject.put("content",exception.getMessage());
                    response.getWriter().write(jsonObject.toJSONString());
                })
                /*无权限访问处理*/
                .and().exceptionHandling().accessDeniedHandler((HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AccessDeniedException e)->
                {
                    httpServletResponse.setContentType("application/json;charset=utf-8");
                    JSONObject jsonObject = new JSONObject();
                    jsonObject.put("code",HttpStatus.FORBIDDEN);
                    jsonObject.put("msg", "无权限访问");
                    jsonObject.put("content",e.getMessage());
                    httpServletResponse.getWriter().write(jsonObject.toJSONString());
                })
                /*匿名用户访问无权限资源时的异常*/
                .and().exceptionHandling().authenticationEntryPoint((HttpServletRequest request, HttpServletResponse response, AuthenticationException authException)->
                {
                    response.setContentType("application/json;charset=utf-8");
                    JSONObject jsonObject = new JSONObject();
                    jsonObject.put("code",HttpStatus.FORBIDDEN);
                    jsonObject.put("msg","无访问权限");
                    response.getWriter().write(jsonObject.toJSONString());
                })
                .and().authorizeRequests()
                /*基于token，所以不需要session*/
                .and().sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                /*由于使用的是jwt，这里不需要csrf防护并且禁用缓存*/
               .and().csrf().disable().headers().cacheControl();
                /*token过滤*/
                http.addFilterBefore(authenticationTokenFilterBean(),UsernamePasswordAuthenticationFilter.class);
    }

    @Override
    protected void configure(AuthenticationManagerBuilder authenticationManagerBuilder) throws Exception
    {
        authenticationManagerBuilder.userDetailsService(sysUserDetailsService).passwordEncoder(new PasswordEncoder()
        {
            /** 
             * 
             * Description:用户输入的密码加密
             * @param charSequence
             * @author huangweicheng
             * @date 2019/10/21   
            */ 
            @Override
            public String encode(CharSequence charSequence)
            {
                try {
                    return Common.md5(charSequence.toString());
                }catch (NoSuchAlgorithmException e){
                    e.printStackTrace();
                }
                return null;
            }
            
            /** 
             * 
             * Description: 与数据库的密码匹配
             * @param charSequence 用户密码
             * @param encodedPassWord 数据库密码
             * @author huangweicheng
             * @date 2019/10/21   
            */ 
            @Override
            public boolean matches(CharSequence charSequence, String encodedPassWord)
            {
                try {
                    return encodedPassWord.equals(Common.md5(charSequence.toString()));
                }catch (NoSuchAlgorithmException e){
                    e.printStackTrace();
                }
                return false;
            }
        });
    }
　　//token过滤器
    @Bean
    public JwtAuthenticationFilter authenticationTokenFilterBean()
    {
        return new JwtAuthenticationFilter();
    }
}

注解很多都解释清楚，就不过多介绍了。因为security已经将实现登陆的功能封装完成，需要我们做的其实并不多，我们要做仅是查找用户，将查询用户的信息，包括密码，角色等等交给UserDtails，然后在配置里进行自定义验证（可以是md5或其他加密方式），持久层用的是jpa

用户类

import io.swagger.annotations.ApiModel;
import lombok.Data;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * 
 * Description:用户信息
 * @author huangweicheng
 * @date 2019/10/21   
*/ 
@Entity
@Data
@ApiModel
@Table(name = "t_sys_user")
public class SysUserVo extends SysBaseVo implements UserDetails
{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "user_id")
    private int id;

    @Column(name = "user_name")
    private String userName;

    @Column(name = "password")
    private String password;

    @Column(name = "error_num")
    private int errorNum;

    @Column(name = "password_weak")
    private int passwordWeak;

    @Column(name = "forbid")
    private int forbid;

    @Column(name = "uuid")
    private String uuid;

    /** 
     * CascadeType.REMOVE 级联删除，FetchType.LAZY懒加载，不会马上从数据库中加载
     * name中间表名称
     * @JoinColumn t_sys_user的user_id与中间表user_id的映射关系
     * @inverseJoinColumns 中间表另一字段与对应表关联关系
    */ 
    @ManyToMany(cascade = CascadeType.REMOVE,fetch = FetchType.EAGER)
    @JoinTable(name = "t_sys_user_roles",joinColumns = @JoinColumn(name="user_id",referencedColumnName = "user_id"),inverseJoinColumns = @JoinColumn(name = "role_id",referencedColumnName = "role_id"))
    private List roles;
    /** 
     * 
     * Description:权限信息
     * @param
     * @author huangweicheng
     * @date 2019/10/21   
    */ 
    @Override
    public Collectionextends GrantedAuthority> getAuthorities()
    {
        List authorityList = new ArrayList<>();
        List roles = this.getRoles();
        for (SysRoleVo role : roles)
        {
            authorityList.add(new SimpleGrantedAuthority(role.getRoleName()));
        }
        return authorityList;
    }

    @Override
    public String getUsername()
    {
        return this.userName;
    }

    /**
     *
     * Description:账户是否过期
     * @param
     * @author huangweicheng
     * @date 2019/10/21
    */
    @Override
    public boolean isAccountNonExpired()
    {
        return true;
    }

    /**
     *
     * Description:账户是否被冻结
     * @param
     * @author huangweicheng
     * @date 2019/10/21
    */
    @Override
    public boolean isAccountNonLocked()
    {
        if (forbid != 1)
        {
            return false;
        }
        return true;
    }

    /**
     *
     * Description:账户密码是否过期，密码要求性高会使用到，比较每隔一段时间就要求用户重置密码
     * @param
     * @author huangweicheng
     * @date 2019/10/21
    */
    @Override
    public boolean isCredentialsNonExpired()
    {
        return true;
    }
    
    /** 
     * 
     * Description:账户是否可用
     * @param
     * @author huangweicheng
     * @date 2019/10/21   
    */ 
    @Override
    public boolean isEnabled()
    {
        if (bUse != 1)
        {
            return false;
        }
        return true;
    }
}

角色类Role

import io.swagger.annotations.ApiModel;
import lombok.Data;

import javax.persistence.*;

@Entity
@Data
@ApiModel
@Table(name = "t_sys_role")
public class SysRoleVo extends SysBaseVo
{
    @Id
    @GeneratedValue
    @Column(name = "role_id")
    private int roleId;

    @Column(name = "role_name")
    private String roleName;
}

因为我喜欢把相同的属性抽出来，所以定义了一个基类，也可以不这么干

import io.swagger.annotations.ApiModel;
import lombok.Data;

import javax.persistence.*;

@Entity
@Data
@ApiModel
@Table(name = "t_sys_role")
public class SysRoleVo extends SysBaseVo
{
    @Id
    @GeneratedValue
    @Column(name = "role_id")
    private int roleId;

    @Column(name = "role_name")
    private String roleName;
}

接下来就简单多了，只需要在定义一个实现类去实现UserDetailService，基本的登录其实就完成了。

import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * 
 * Description:账户详情信息
 * @author huangweicheng
 * @date 2019/10/21   
*/ 
@Service
public class SysUserDetailsServiceImpl implements UserDetailsService
{
    @Resource
    private SysUserRepository sysUserRepository;

    @Override
    public UserDetails loadUserByUsername(String userName) throws UsernameNotFoundException
    {
        SysUserVo sysUser = sysUserRepository.findByUserName(userName);
        if (sysUser == null)
        {
            throw new UsernameNotFoundException(userName);
        }
        return sysUser;
    }
}

JWT

jwt的相关介绍就不多废话了，不了解可以查看阮大神的博客 

JwtTokenUtil工具类（剽窃林老师的代码）

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

import java.io.Serializable;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * 
 * Description: token相关的工具类
 * @author huangweicheng
 * @date 2019/10/23   
*/
@Component
public class JwtTokenUtil implements Serializable
{
    private static final long serialVersionUID = -4324967L;

    private static final String CLAIM_KEY_USERNAME = "sub";
    private static final String CLAIM_KEY_CREATED = "created";
    private static final String CLAIM_KEY_ROLES = "roles";

    @Autowired
    private RedisTemplate redisTemplate;

    @Value("${jwt.secret}")
    private String secret;

    @Value("${jwt.expiration}")
    private Long expiration;

    /** 
     * 
     * Description: 解析token，从token中获取信息
     * @param token
     * @author huangweicheng
     * @date 2019/10/23   
    */ 
    private Claims getClaimsFromToken(String token)
    {
        Claims claims;
        try {
            claims = Jwts.parser()
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
        }catch (Exception e){
            e.printStackTrace();
            claims = null;
        }
        return claims;
    }
    
    /** 
     * 
     * Description:获取用户名
     * @param token
     * @author huangweicheng
     * @date 2019/10/23   
    */ 
    public String getUserNameFromToken(String token)
    {
        String userName;
        try {
            final Claims claims = getClaimsFromToken(token);
            userName = claims.getSubject();
        }catch (Exception e){
            userName = null;
        }
        return userName;
    }
    
    /** 
     * 
     * Description:从token中获取
     * @param token
     * @author huangweicheng
     * @date 2019/10/25   
    */ 
    public String getRolesFromToken(String token)
    {
        String roles;
        try {
            final Claims claims =  getClaimsFromToken(token);
            roles = (String) claims.get(CLAIM_KEY_ROLES);
        }catch (Exception e){
            roles = null;
        }
        return roles;
    }
    /** 
     * 
     * Description:获取token创建时间
     * @param token
     * @author huangweicheng
     * @date 2019/10/23   
    */ 
    public Date getCreatedDateFromToken(String token)
    {
        Date created;
        try {
            final Claims claims = getClaimsFromToken(token);
            created = new Date((Long) claims.get(CLAIM_KEY_CREATED));
        }catch (Exception e){
            created = null;
        }
        return created;
    }
    
    /** 
     * 
     * Description: 获取token过期时间
     * @param token
     * @author huangweicheng
     * @date 2019/10/23   
    */ 
    public Date getExpirationDateFromToken(String token)
    {
        Date expiration;
        try {
            final Claims claims = getClaimsFromToken(token);
            expiration = claims.getExpiration();
        }catch (Exception e){
            expiration = null;
        }
        return expiration;
    }
    
    /** 
     *
     * Description:token生成过期时间
     * @param 
     * @author huangweicheng
     * @date 2019/10/23   
    */ 
    private Date generateExpirationDate()
    {
        return new Date(System.currentTimeMillis() + expiration * 1000);
    }

    /** 
     * 
     * Description:token是否过期
     * @param token
     * @author huangweicheng
     * @date 2019/10/23   
    */ 
    private Boolean isTokenExpired(String token)
    {
        final Date expiration = getExpirationDateFromToken(token);
        return expiration.before(new Date());
    }
    
    /** 
     * 
     * Description:token创建时间与密码最后修改时间比较，小于返回true，大于返回false
     * @param created
     * @param lastPasswordReset
     * @author huangweicheng
     * @date 2019/10/24   
    */ 
    private Boolean isCreatedBeforeLastPasswordReset(Date created,Date lastPasswordReset)
    {
        return (lastPasswordReset != null && created.before(lastPasswordReset));
    }
    /** 
     * 
     * Description: 创建token
     * @param userDetails
     * @author huangweicheng
     * @date 2019/10/23   
    */ 
    public String generateToken(UserDetails userDetails)
    {
        String roles = "";
        Collectionextends GrantedAuthority> authorities = userDetails.getAuthorities();
        for (GrantedAuthority authority : authorities)
        {
            String temp = authority.getAuthority() + ",";
            roles += temp;
        }
        roles = roles.substring(0,roles.length() - 1);
        Map claims = new HashMap<>();
        claims.put(CLAIM_KEY_USERNAME,userDetails.getUsername());
        claims.put(CLAIM_KEY_CREATED,new Date());
        claims.put(CLAIM_KEY_ROLES,roles);
        return generateToken(claims);
    }
    /** 
     * 
     * Description:使用Rs256签名
     * @param claims
     * @author huangweicheng
     * @date 2019/10/23   
    */ 
    private String generateToken(Map claims)
    {
        return Jwts.builder()
                .setClaims(claims)
                .setExpiration(generateExpirationDate())
                .signWith(SignatureAlgorithm.HS512,secret)
                .compact();
    }
    
    /** 
     * 
     * Description:是否刷新token
     * @param token
     * @param lastPasswordReset
     * @author huangweicheng
     * @date 2019/10/23   
    */ 
    public Boolean canTokenBeRefreshed(String token, Date lastPasswordReset) {
        final Date created = getCreatedDateFromToken(token);
        return !isCreatedBeforeLastPasswordReset(created, lastPasswordReset)
                && !isTokenExpired(token);
    }
    
    /** 
     * 
     * Description:刷新token
     * @param token
     * @author huangweicheng
     * @date 2019/10/23   
    */ 
    public String refreshToken(String token)
    {
        String refreshToken;
        try {
            final Claims claims = getClaimsFromToken(token);
            claims.put(CLAIM_KEY_CREATED,new Date());
            refreshToken = generateToken(claims);
        }catch (Exception e){
            refreshToken = null;
        }
        return refreshToken;
    }

    /**
     *
     * Description:验证token
     * @param token
     * @param userDetails
     * @author huangweicheng
     * @date 2019/10/24
    */
    public boolean validateToken(String token)
    {
        final String username = getUserNameFromToken(token);
        if (redisTemplate.hasKey(username + "huangweicheng") && !isTokenExpired(token))
        {
            //如果验证成功，说明此用户进行了一次有效操作，延长token的过期时间
            redisTemplate.boundValueOps(username + "subjectrace").expire(this.expiration,TimeUnit.MINUTES);
            return true;
        }
        return false;
    }

 现在我们设置token过滤，请求接口没有token或者token已经过期，就会跳到登录页面

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * 
 * Description:token的拦截器
 * @author huangweicheng
 * @date 2019/10/24   
*/
@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter
{
    @Value("${jwt.header}")
    private String tokenHeader;

    @Value("${jwt.tokenHead}")
    private String tokenHead;

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException
    {
        String token = httpServletRequest.getHeader(this.tokenHeader);
        if (token != null && jwtTokenUtil.validateToken(token))
        {
            String role = jwtTokenUtil.getRolesFromToken(token);
            String[] roles = role.split(",");
            List authorityList = new ArrayList<>();
            for (String r : roles)
            {
                authorityList.add(new SimpleGrantedAuthority(r));
            }
            String username = jwtTokenUtil.getUserNameFromToken(token);
            UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(username,null,authorityList);
            authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(httpServletRequest));
            /*权限设置*/
            SecurityContextHolder.getContext().setAuthentication(authenticationToken);
        }
        filterChain.doFilter(httpServletRequest,httpServletResponse);
    }
}

现在验证的核心内容都已经完成，写几个接口测试下。

HomeController类

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HomeController
{
    @RequestMapping("/admin/test2")
    @ResponseBody
    public String admin2()
    {
        return "ROLE_ADMIN";
    }

}

HwcController类

@Controller
public class HwcController
{
    @GetMapping("/hwc/test")
    @ResponseBody
    public String test()
    {
        return "ROLE_USER";
    }
}

用postman测试一下，没token匿名访问
springboot security+redis+jwt+验证码 登录验证_第2张图片

 

 

 获取验证码后，将验证码写入cookie里，输入账号密码，登录

springboot security+redis+jwt+验证码 登录验证_第3张图片
登录成功

 

 

springboot security+redis+jwt+验证码 登录验证_第4张图片

 

 

token在放在header里

 

 

 

有token，没权限访问
springboot security+redis+jwt+验证码 登录验证_第5张图片

 

 

 有权限有token访问
springboot security+redis+jwt+验证码 登录验证_第6张图片

 

 

 补充

application.properties

#        ┏┓　　　┏┓+ +
#　　　┏┛┻━━━┛┻┓ + +
#　　　┃　　　　　　　┃ 　
#　　　┃　　　━　　　┃ ++ + + +
#　　 ████━████ ┃+
#　　　┃　　　　　　　┃ +
#　　　┃　　　┻　　　┃
#　　　┃　　　　　　　┃ + +
#　　　┗━┓　　　┏━┛
#　　　　　┃　　　┃　　　　　　　　　　　
#　　　　　┃　　　┃ + + + +
#　　　　　┃　　　┃　　　　　　　
#　　　　　┃　　　┃ + 　　　　神兽护体,代码 no bug　　
#　　　　　┃　　　┃
#　　　　　┃　　　┃　　+　　　　　　　　　
#　　　　　┃　 　　┗━━━┓ + +
#　　　　　┃ 　　　　　　　┣┓
#　　　　　┃ 　　　　　　　┏┛
#　　　　　┗┓┓┏━┳┓┏┛ + + + +
#　　　　　　┃┫┫　┃┫┫
#　　　　　　┗┻┛　┗┻┛+ + + +

server.port=8080
server.servlet.context-path=/huangweicheng
server.servlet.session.cookie.http-only=true

spring.http.encoding.force=true
##########################################
####jpa连接                             ##
##########################################
spring.jpa.database = MYSQL
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.generate-ddl=true
#数据库连接
spring.datasource.url = jdbc:mysql://127.0.0.1:3306/hwc_db?characterEncoding=utf8&useSSL=true
spring.datasource.username = root
spring.datasource.password = root
spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect
#jwt 配置
jwt.header=Authorization
jwt.secret=huangweicheng
jwt.expiration=1000
#reids配置
# Redis数据库索引（默认为0）
spring.redis.database=0 
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
#连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.lettuce.pool.max-wait=-1ms
# 连接池中的最大空闲连接
spring.redis.lettuce.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.lettuce.pool.min-idle=0
#日志配置
logging.path=D://log/
logging.file=huangweicheng.log
logging.level.root = INFO
#日志格式
logging.pattern.console=%d{yyyy/MM/dd-HH:mm:ss} [%thread] %-5level %logger- %msg%n
logging.pattern.file=%d{yyyy/MM/dd-HH:mm} [%thread] %-5level %logger- %msg%n

redis相关配置

/**
 * 
 * Description:redis配置，EnableCaching开启缓存
 * @author huangweicheng
 * @date 2019/10/22   
*/
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport
{
    @Bean
    @Override
    public KeyGenerator keyGenerator()
    {
        return (o,method,objects)->
        {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append(o.getClass().getName());
            stringBuilder.append(method.getName());
            for (Object obj : objects)
            {
                stringBuilder.append(obj.toString());
            }
            return stringBuilder.toString();
        };
    }
    /** 
     * 
     * Description: redisTemplate序列化
     * @param factory
     * @author huangweicheng
     * @date 2019/10/22   
    */ 
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory factory)
    {
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(factory);
        FastJsonRedisSerializer fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
        /*设置value值的序列化*/
        redisTemplate.setValueSerializer(fastJsonRedisSerializer);
        redisTemplate.setHashValueSerializer(fastJsonRedisSerializer);
        /*设置key的序列化*/
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setDefaultSerializer(fastJsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
} 
  
 
 
 
 
数据库表
t_sys_user
 
 
 
 
 
 
 
 
 t_sys_user_roles
 
 
 
 
 
 
 
 
t_sys_role
 
 
 
总结
 
 
jwt的token本应该是无状态的认证的，但没到过期时间这个token都是可用的，没法控制，在这期间如果被盗取，将会产生严重后果，所以引入redis控制状态。而且这还是不够严谨，应该进一步引入https的认证。增加信息的安全性，这只是一个demo，如果有需要，请留言，将会整理到码云或github上提供下载。
 
 
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(springboot security+redis+jwt+验证码 登录验证)

        

            

                
    
                    
  • Python神器！WEB自动化测试集成工具 DrissionPage
                        亚丁号
python开发语言
                        
    一、前言用requests做数据采集面对要登录的网站时，要分析数据包、JS源码，构造复杂的请求，往往还要应付验证码、JS混淆、签名参数等反爬手段，门槛较高。若数据是由JS计算生成的，还须重现计算过程，体验不好，开发效率不高。使用浏览器，可以很大程度上绕过这些坑，但浏览器运行效率不高。因此，这个库设计初衷，是将它们合而为一，能够在不同须要时切换相应模式，并提供一种人性化的使用方法，提高开发和运行效率
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
                        瑞金彭于晏
springboot后端javaMVCspring数据库
                        
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    
                    
    • 
                    
  • Java -jar 如何在后台运行项目
                        vincent_hahaha

                        
    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
    
                    
    • 
                    
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架
                        叶准鑫Natalie

                        
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    
                    
    • 
                    
  • 使用Python和Playwright破解滑动验证码
                        asfdsgdf
python开发语言
                        
    滑动验证码是一种常见的验证码形式，通过拖动滑块将缺失的拼图块对准原图中的空缺位置来验证用户操作。本文将介绍如何使用Python中的OpenCV进行模板匹配，并结合Playwright实现自动化破解滑动验证码的过程。所需技术OpenCV模板匹配：用于识别滑块在背景图中的正确位置。Python：主要编程语言。Playwright：用于浏览器自动化，模拟用户操作。破解过程概述获取验证码图像：下载背景图和
    
                    
    • 
                    
  • Playwright 自动化验证码教程
                        吉小雨
python库自动化数据库运维python
                        
    Playwright自动化点击验证码教程在自动化测试中，Playwright是一个流行的浏览器自动化工具，支持多种浏览器的高效操作。验证码（如图片验证码、滑动验证码等）是网页中常见的反自动化机制，常常需要特别处理。我们将介绍如何使用Playwright自动化点击验证码，并提供几种常见验证码的处理方案。官方文档链接：Playwright官方文档一、Playwright环境搭建1.1安装Playwri
    
                    
    • 
                    
  • 【中国国际航空-注册_登录安全分析报告】
                        风控牛
验证码接口安全评测系列安全行为验证极验网易易盾智能手机
                        
    前言由于网站注册入口容易被黑客攻击，存在如下安全问题：1.暴力破解密码，造成用户信息泄露2.短信盗刷的安全问题，影响业务及导致用户投诉3.带来经济损失，尤其是后付费客户，风险巨大，造成亏损无底洞所以大部分网站及App都采取图形验证码或滑动验证码等交互解决方案，但在机器学习能力提高的当下，连百度这样的大厂都遭受攻击导致点名批评，图形验证及交互验证方式的安全性到底如何？请看具体分析一、中国国际航空PC
    
                    
    • 
                    
  • Python编写简单登录系统的完整指南
                        qq_35430208
pythonpython开发语言Python编写简单登录系统登录系统
                        
    在现代应用中，用户认证和登录系统是一个非常重要的功能。通过登录系统，应用能够识别用户的身份，并为其提供相应的权限和服务。本文将介绍如何使用Python编写一个简单的登录系统，包括用户注册、登录验证、密码加密等功能。通过这一教程，将学习如何构建一个基本的用户登录系统，并理解其中的关键技术。系统需求分析一个基本的登录系统应该具备以下功能：用户注册：新用户可以创建账号，系统会将用户名和密码存储起来。登录
    
                    
    • 
                    
  • Sentinel实时监控不展示问题
                        朱杰jjj
sentinelsentinel
                        
    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
    
                    
    • 
                    
  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
                        这孩子叫逆
Mybatis笔记mybatis数据库
                        
    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
    
                    
    • 
                    
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算
                        码踏云端
springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
                        
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    
                    
    • 
                    
  • java 技术 架构 相关文档
                        圣心
java架构开发语言
                        
    在Java中，有许多不同的技术和架构，这里我将列举一些常见的Java技术和架构，并提供一些相关的文档资源。SpringFrameworkSpring是一个开源的Java/JavaEE全功能框架，以Apache许可证形式发布，提供了一种实现企业级应用的方法。官方文档：SpringFrameworkSpringBootSpringBoot是Spring的一个子项目，旨在简化创建生产级的Spring应用
    
                    
    • 
                    
  • java获取applicationcontext,SpringBoot获取ApplicationContext的3种方式
                        花儿街参考

                        
    ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能。ApplicationContext获取的几种方式1直接使用Autowired注入@ComponentpublicclassBook1{@AutowiredprivateApplicationContextapplicationContext;pub
    
                    
    • 
                    
  • SpringBoot 设置传入参数非必要
                        loveLifeLoveCoding
springbootspringbootjavaspring
                        
    查看RequestParam源码packageorg.springframework.web.bind.annotation;importjava.lang.annotation.Documented;importjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotat
    
                    
    • 
                    
  • SpringBoot 获取 ApplicationContext
                        loveLifeLoveCoding
springbootspringbootjavaspring
                        
    1.概念ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能2.获取ApplicationContext的方式2.1.创建工具类通过此工具类，可以方便的获取bean组件,获取配置信息等importorg.springframework.beans.BeansException;importorg.spr
    
                    
    • 
                    
  • 关于项目中使用shiro进行安全管理的总结
                        一颗大青柠
JavaShirojavaspring
                        
    关于项目中使用shiro进行安全管理的总结关于SpringBoot下使用shiro进行用户认证与权限管理对于安全框架有一定了解的开发者一定对于shiro这款安全框架有一定的了解，这里我们不再对该框架进行其设计与知识的介绍，仅对于我的个人项目中所使用到的进行一个总结，并放上代码。使用该框架的第一步，进行配置：packagecom.libvirtjava.demo.vm.util.config;imp
    
                    
    • 
                    
  • Spring Boot 请求处理流程：从负载均衡到多实例并发 - 电子商务网站实例
                        烟雨国度
springboot负载均衡后端
                        
    SpringBoot请求处理流程：从负载均衡到多实例并发-电子商务网站实例SpringBoot请求处理流程：从负载均衡到多实例并发SpringBoot作为一个强大的Java应用开发框架，能够有效地处理高并发请求。本文将基于三个关键流程图，详细分析SpringBoot应用如何从负载均衡到请求处理，再到多实例并发处理的整个过程。1.负载均衡和多实例处理首先，让我们看一下描述负载均衡和多实例处理的流程图
    
                    
    • 
                    
  • 微服务架构 | nacos - [自动刷新配置方式 & 失效排查]
                        问仙长何方蓬莱
微服务java技术SpringCloud微服务javanacos
                        
    INDEX§1配置方式§1.1springboot配置§1.2springcloud配置§2失效排查§2.1常见失效场景§2.1.1配置不配套§2.1.2自动刷新未开启§2.1.3依赖冲突§2.1.4改错了配置文件§2.2未知情况关键排查点§1配置方式nacos的配置中心主要有两套配置方式，配置方式不互相共通，需要配套配置springbootspringcloud§1.1springboot配置依
    
                    
    • 
                    
  • 【免费】springboot项目申报管理系统|毕业设计|Javaweb项目
                        计算机学姐来啦
springbootssmjavaspringboot课程设计后端毕设毕业设计java-ee
                        
    收藏点赞不迷路关注作者有好处编号：springboot375springboot项目申报管理系统开发语言：Java数据库：MySQL技术：Spring+SpringMVC+MyBatis工具：IDEA/Ecilpse、Navicat、Maven1.万字文档展示(部分)2.系统图片展示第5章系统详细设计5.1管理员功能模块的实现5.1.1项目列表如图5.1显示的就是项目列表页面，此页面提供给管理员的
    
                    
    • 
                    
  • springboot与日志
                        最后的夏t

                        
    日志1、日志框架小张；开发一个大型系统；1、System.out.println("")；将关键数据打印在控制台；去掉？写在一个文件？2、框架来记录系统的一些运行时信息；日志框架；zhanglogging.jar；3、高大上的几个功能？异步模式？自动归档？xxxx？zhanglogging-good.jar？4、将以前框架卸下来？换上新的框架，重新修改之前相关的API；zhanglogging-p
    
                    
    • 
                    
  • 计算机信息管理本科自考选题推荐
                        李哥讲程序开发
javaspringboot开发语言
                        
    计算机信息管理专业是一个跨学科的领域，它结合了计算机技术与管理技术，旨在利用计算机完成各类信息管理。以下是一些推荐的自考选题方向：基于SSM的毕业设计管理系统的设计与实现基于SSM大学生校园兼职论坛管理系统基于SSM的家教应聘招聘系统的设计和实现基于SpringBoot住院患者满意度跟踪调查系统的设计与实现基于SpringBoot在线作业提交系统的设计与实现总的来说，这些建议的选题方向覆盖了计算机
    
                    
    • 
                    
  • springboot+mybatisplus实现基本的增删改查以及分页查询。这里使用的是Restful风格包括简单描述Restful是什么
                        okchan666
springbootjava
                        
    先实现springboot+mybatisplus的增删改查接口使用postman测试：第一步创建项目导入依赖：直接给大家了：4.0.0org.springframework.bootspring-boot-starter-parent2.6.6com.okchanspringboot_07_ssmp0.0.1-SNAPSHOT1.8org.springframework.bootspring-b
    
                    
    • 
                    
  • SpringBoot2：web开发常用功能实现及原理解析-整合EasyExcel实现Excel导入导出功能
                        生产队队长
SpringAllexcelspringboot
                        
    1、工程包结构主要是这5个Java类2、导入EasyExcel包这里同时贴出其他相关springboot的基础包org.springframework.bootspring-boot-starter-weborg.springframework.bootspring-boot-devtoolsruntimetrueorg.springframework.bootspring-boot-config
    
                    
    • 
                    
  • nacos管理springboot配置时，发生的Could not resolve placeholder两种原因
                        生产队队长
SpringAllspringboot
                        
    IllegalArgumentException:Couldnotresolveplaceholder'xxx.xxx.xxx'invalue"${xxx.xxx.xxx}"第一种：确实缺少配置，加上对应的配置即可。第二种：这个情况，可能会迷惑很多人报错某个配置无法引用，但是，检查配置时，确实存在，已经配置好了。而且，整个yml文件也没有语法格式错误。原因：我们在解决第一个问题的时候，可能导致这个
    
                    
    • 
                    
  • springboot整合MongoDB时碰到的问题
                        生产队队长
DatabaseSpringAllmongodbspring
                        
    1.账号总是不对，导致查不出数据，报错Auth…权鉴错误这次，我也是第一次接触MongoDB，非常的生疏springboot整合MongoDB，要在properties文件中配置账号mongodb基本语法：useDATABASE_NAME;--创建数据库showdbs;--查看我们所有的库，注意，我们刚创建的库，如果没有数据，是不会被显示的showusers;--查看当前库所有拥有的账号db.cr
    
                    
    • 
                    
  • 网上商城项目总结 续
                        猫只i
javaweb电子商城结构
                        
    前台1.用户登录注册邮箱验证校验用户名是否存在验证码自动登录2.导航条自定义标签库采用异步读取数据（使用gson将集合转换json数据）Redis服务器3.首页热门商品查询展示4.分类列表分页查询5.商品详情用cookie实现浏览记录6.购物车实现商品添加到购物车商品的查询，添加，修改，删除清空购物车7.提交订单添加订单（订单详情）确认订单（易宝支付）8.我的订单9.Fliter定义权限拦截（提交
    
                    
    • 
                    
  • python基于django/flask的NBA球员大数据分析与可视化python+java+node.js
                        QQ_511008285
pythondjangoflaskjavaspringboot数据分析
                        
    前端开发框架:vue.js数据库mysql版本不限后端语言框架支持：1java(SSM/springboot)-idea/eclipse2.Nodejs+Vue.js-vscode3.python(flask/django)--pycharm/vscode4.php(thinkphp/laravel)-hbuilderx数据库工具：Navicat/SQLyog等都可以本文针对NBA球员的大数据进行
    
                    
    • 
                                
  • java工厂模式
                                    3213213333332132
java抽象工厂
                                    
    工厂模式有 
1、工厂方法 
2、抽象工厂方法。 
 
下面我的实现是抽象工厂方法, 
 
给所有具体的产品类定一个通用的接口。 
 

package 工厂模式;

/**
 * 航天飞行接口
 * 
 * @Description
 * @author FuJianyong
 * 2015-7-14下午02:42:05
 */
public interface SpaceF
    
                                
    • 
                                
  • nginx频率限制+python测试
                                    ronin47
nginx 频率 python
                                    
           
部分内容参考：http://www.abc3210.com/2013/web_04/82.shtml 
首先说一下遇到这个问题是因为网站被攻击，阿里云报警，想到要限制一下访问频率，而不是限制ip（限制ip的方案稍后给出）。nginx连接资源被吃空返回状态码是502，添加本方案限制后返回599，与正常状态码区别开。步骤如下：
    
                                
    • 
                                
  • java线程和线程池的使用
                                    dyy_gusi
ThreadPoolthreadRunnabletimer
                                    
    java线程和线程池 
一、创建多线程的方式 
    java多线程很常见，如何使用多线程，如何创建线程，java中有两种方式，第一种是让自己的类实现Runnable接口，第二种是让自己的类继承Thread类。其实Thread类自己也是实现了Runnable接口。具体使用实例如下： 
1、通过实现Runnable接口方式          1   2   
    
                                
    • 
                                
  • Linux
                                    171815164
linux
                                    
    ubuntu kernel 
http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.1.2-unstable/ 
 
安卓sdk代理 
mirrors.neusoft.edu.cn        80 
 
输入法和jdk 
sudo apt-get install fcitx 
su
    
                                
    • 
                                
  • Tomcat JDBC Connection Pool
                                    g21121
Connection
                                    
           Tomcat7 抛弃了以往的DBCP 采用了新的Tomcat Jdbc Pool 作为数据库连接组件，事实上DBCP已经被Hibernate 所抛弃，因为他存在很多问题，诸如：更新缓慢，bug较多，编译问题，代码复杂等等。 
       Tomcat Jdbc P
    
                                
    • 
                                
  • 敲代码的一点想法
                                    永夜-极光
java随笔感想
                                    
                  入门学习java编程已经半年了,一路敲代码下来,现在也才1w+行代码量,也就菜鸟水准吧,但是在整个学习过程中,我一直在想,为什么很多培训老师,网上的文章都是要我们背一些代码?比如学习Arraylist的时候,教师就让我们先参考源代码写一遍,然
    
                                
    • 
                                
  • jvm指令集
                                    程序员是怎么炼成的
jvm 指令集
                                    
    转自：http://blog.csdn.net/hudashi/article/details/7062675#comments 
  
  
  
将值推送至栈顶时 const ldc  push   load指令 
const系列 
该系列命令主要负责把简单的数值类型送到栈顶。(从常量池或者局部变量push到栈顶时均使用) 
0x02 &nbs
    
                                
    • 
                                
  • Oracle字符集的查看查询和Oracle字符集的设置修改
                                    aijuans
oracle
                                    
     本文主要讨论以下几个部分：如何查看查询oracle字符集、 修改设置字符集以及常见的oracle utf8字符集和oracle exp 字符集问题。 
一、什么是Oracle字符集  
 Oracle字符集是一个字节数据的解释的符号集合,有大小之分,有相互的包容关系。ORACLE 支持国家语言的体系结构允许你使用本地化语言来存储，处理，检索数据。它使数据库工具，错误消息，排序次序，日期，时间，货
    
                                
    • 
                                
  • png在Ie6下透明度处理方法
                                    antonyup_2006
css浏览器FirebugIE
                                    
    由于之前到深圳现场支撑上线，当时为了解决个控件下载，我机器上的IE8老报个错，不得以把ie8卸载掉，换个Ie6,问题解决了，今天出差回来，用ie6登入另一个正在开发的系统，遇到了Png图片的问题，当然升级到ie8(ie8自带的开发人员工具调试前端页面JS之类的还是比较方便的，和FireBug一样，呵呵)，这个问题就解决了，但稍微做了下这个问题的处理。 
 
我们知道PNG是图像文件存储格式，查询资
    
                                
    • 
                                
  • 表查询常用命令高级查询方法(二)
                                    百合不是茶
oracle分页查询分组查询联合查询
                                    
    ----------------------------------------------------分组查询 group by    having   --平均工资和最高工资   select avg(sal)平均工资,max(sal)  from emp ;  --每个部门的平均工资和最高工资
    
                                
    • 
                                
  • uploadify3.1版本参数使用详解
                                    bijian1013
JavaScriptuploadify3.1
                                    
    使用： 
    绑定的界面元素<input id='gallery'type='file'/>$("#gallery").uploadify({设置参数，参数如下}); 
设置的属性： 
id: jQuery(this).attr('id'),//绑定的input的ID
      langFile: 'http://ww
    
                                
    • 
                                
  • 精通Oracle10编程SQL(17)使用ORACLE系统包
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *使用ORACLE系统包
 */
--1.DBMS_OUTPUT
--ENABLE:用于激活过程PUT,PUT_LINE,NEW_LINE,GET_LINE和GET_LINES的调用
--语法：DBMS_OUTPUT.enable(buffer_size in integer default 20000);

--DISABLE:用于禁止对过程PUT,PUT_LINE,NEW
    
                                
    • 
                                
  • 【JVM一】JVM垃圾回收日志
                                    bit1129
垃圾回收
                                    
    将JVM垃圾回收的日志记录下来，对于分析垃圾回收的运行状态，进而调整内存分配(年轻代，老年代，永久代的内存分配)等是很有意义的。JVM与垃圾回收日志相关的参数包括： 
 
 -XX:+PrintGC 
 -XX:+PrintGCDetails 
 -XX:+PrintGCTimeStamps  
 -XX:+PrintGCDateStamps 
 -Xloggc 
 -XX:+PrintGC 
通
    
                                
    • 
                                
  • Toast使用
                                    白糖_
toast
                                    
    Android中的Toast是一种简易的消息提示框，toast提示框不能被用户点击，toast会根据用户设置的显示时间后自动消失。 
  
  
 
 创建Toast 
   两个方法创建Toast   
makeText(Context context, int resId, int duration)  
  
  参数：context是toast显示在
    
                                
    • 
                                
  • angular.identity
                                    boyitech
AngularJSAngularJS API
                                    
    angular.identiy   描述:   返回它第一参数的函数. 此函数多用于函数是编程.    使用方法:   angular.identity(value);   参数详解:      Param Type Details   value 
*  
to be returned.      返回值:   传入的value   实例代码:   
<!DOCTYPE HTML>

    
                                
    • 
                                
  • java-两整数相除，求循环节
                                    bylijinnan
java
                                    
    
import java.util.ArrayList;
import java.util.List;

public class CircleDigitsInDivision {

	/**
	 * 题目：求循环节，若整除则返回NULL，否则返回char*指向循环节。先写思路。函数原型：char*get_circle_digits(unsigned k,unsigned j) 

    
                                
    • 
                                
  • Java 日期 周 年
                                    Chen.H
javaC++cC#
                                    
    

/**
 * java日期操作(月末、周末等的日期操作)
 * 
 * @author 
 * 
 */
public class DateUtil {
	
    /** */
    /**
     * 取得某天相加(减)後的那一天
     * 
     * @param date
     * @param num
     *           
    
                                
    • 
                                
  • [高考与专业]欢迎广大高中毕业生加入自动控制与计算机应用专业
                                    comsci
计算机
                                    
     
 
      不知道现在的高校还设置这个宽口径专业没有,自动控制与计算机应用专业,我就是这个专业毕业的,这个专业的课程非常多,既要学习自动控制方面的课程,也要学习计算机专业的课程,对数学也要求比较高.....如果有这个专业,欢迎大家报考...毕业出来之后,就业的途径非常广..... 
 
     以后
    
                                
    • 
                                
  • 分层查询（Hierarchical Queries）
                                    daizj
oracle递归查询层次查询
                                    
    Hierarchical Queries 
 
If a table contains hierarchical data, then you can select rows in a hierarchical order using the hierarchical query clause: 
 
hierarchical_query_clause::= 
 
start with condi
    
                                
    • 
                                
  • 数据迁移
                                    daysinsun
数据迁移
                                    
    最近公司在重构一个医疗系统，原来的系统是两个.Net系统，现需要重构到java中。数据库分别为SQL Server和Mysql，现需要将数据库统一为Hana数据库，发现了几个问题，但最后通过努力都解决了。 
1、原本通过Hana的数据迁移工具把数据是可以迁移过去的，在MySQl里面的字段为TEXT类型的到Hana里面就存储不了了，最后不得不更改为clob。 
 
2、在数据插入的时候有些字段特别长
    
                                
    • 
                                
  • C语言学习二进制的表示示例
                                    dcj3sjt126com
cbasic
                                    
    进制的表示示例 
# include <stdio.h>

int main(void)
{
	int i = 0x32C;

	printf("i = %d\n", i);
	/*
		printf的用法
		%d表示以十进制输出
		%x或%X表示以十六进制的输出
		%o表示以八进制输出
	*/

	return 0;
}
 

    
                                
    • 
                                
  • NsTimer 和 UITableViewCell 之间的控制
                                    dcj3sjt126com
ios
                                    
    情况是这样的: 
一个UITableView, 每个Cell的内容是我自定义的 viewA viewA上面有很多的动画, 我需要添加NSTimer来做动画, 由于TableView的复用机制, 我添加的动画会不断开启, 没有停止, 动画会执行越来越多. 
  
解决办法: 
在配置cell的时候开始动画, 然后在cell结束显示的时候停止动画 
  
查找cell结束显示的代理
    
                                
    • 
                                
  • MySql中case when then 的使用
                                    fanxiaolong
casewhenthenend
                                    
    select "主键",  "项目编号", "项目名称","项目创建时间", "项目状态","部门名称","创建人"

union

(select
	pp.id as "主键",
	pp.project_number as &
    
                                
    • 
                                
  • Ehcache（01）——简介、基本操作
                                    234390216
cacheehcache简介CacheManagercrud
                                    
    Ehcache简介 
目录 
1       CacheManager 
1.1      构造方法构建 
1.2      静态方法构建 
2       Cache 
2.1&
    
                                
    • 
                                
  • 最容易懂的javascript闭包学习入门
                                    jackyrong
JavaScript
                                    
    http://www.ruanyifeng.com/blog/2009/08/learning_javascript_closures.html 
 
闭包（closure）是Javascript语言的一个难点，也是它的特色，很多高级应用都要依靠闭包实现。 
下面就是我的学习笔记，对于Javascript初学者应该是很有用的。 
一、变量的作用域 
要理解闭包，首先必须理解Javascript特殊
    
                                
    • 
                                
  • 提升网站转化率的四步优化方案
                                    php教程分享
数据结构PHP数据挖掘Google活动
                                    
    网站开发完成后,我们在进行网站优化最关键的问题就是如何提高整体的转化率，这也是营销策略里最最重要的方面之一，并且也是网站综合运营实例的结果。文中分享了四大优化策略：调查、研究、优化、评估，这四大策略可以很好地帮助用户设计出高效的优化方案。 
PHP开发的网站优化一个网站最关键和棘手的是，如何提高整体的转化率，这是任何营销策略里最重要的方面之一，而提升网站转化率是网站综合运营实力的结果。今天，我就分
    
                                
    • 
                                
  • web开发里什么是HTML5的WebSocket？
                                    naruto1990
Webhtml5浏览器socket
                                    
    当前火起来的HTML5语言里面，很多学者们都还没有完全了解这语言的效果情况，我最喜欢的Web开发技术就是正迅速变得流行的 WebSocket API。WebSocket 提供了一个受欢迎的技术，以替代我们过去几年一直在用的Ajax技术。这个新的API提供了一个方法，从客户端使用简单的语法有效地推动消息到服务器。让我们看一看6个HTML5教程介绍里 的 WebSocket API：它可用于客户端、服
    
                                
    • 
                                
  • Socket初步编程——简单实现群聊
                                    Everyday都不同
socket网络编程初步认识
                                    
    初次接触到socket网络编程，也参考了网络上众前辈的文章。尝试自己也写了一下，记录下过程吧： 
  
服务端：（接收客户端消息并把它们打印出来） 
  
public class SocketServer {
	private List<Socket> socketList = new ArrayList<Socket>();
	 public s
    
                                
    • 
                                
  • 面试：Hashtable与HashMap的区别（结合线程）
                                    toknowme

                                    
    昨天去了某钱公司面试，面试过程中被问道 
Hashtable与HashMap的区别？当时就是回答了一点，Hashtable是线程安全的，HashMap是线程不安全的，说白了，就是Hashtable是的同步的，HashMap不是同步的，需要额外的处理一下。 
  
今天就动手写了一个例子，直接看代码吧 
package com.learn.lesson001;

import java
    
                                
    • 
                                
  • MVC设计模式的总结
                                    xp9802
设计模式mvc框架IOC
                                    
    随着Web应用的商业逻辑包含逐渐复杂的公式分析计算、决策支持等，使客户机越 
来越不堪重负，因此将系统的商业分离出来。单独形成一部分，这样三层结构产生了。 
其中‘层’是逻辑上的划分。 
三层体系结构是将整个系统划分为如图2.1所示的结构[3] 
 
 
（1）表现层（Presentation layer）：包含表示代码、用户交互GUI、数据验证。 
该层用于向客户端用户提供GUI交互，它允许用户
    
                                
    •