精华内容
下载资源
问答
  • 下面小编就为大家分享一篇spring boot 自动更新静态文件和后台代码的实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • spring boot后台运行方法

    千次阅读 2018-08-03 19:27:59
    spring boot后台运行方法: 除了下文中的方式,还有一个supervisor配置的方法;无论哪种方式底层都是java -jar来启动; 我们测试环境用Jenkins自动化发版; 线上用assembly打包给运维人员,assembly是根据这个博客...

    QQ:2522745405,欢迎留言讨论。

    spring boot后台运行方法:

    除了下文中的方式,还有一个supervisor配置的方法;无论哪种方式底层都是java -jar来启动;

    我们测试环境用Jenkins自动化发版;
    线上用assembly打包给运维人员,assembly是根据这个博客进行编写的脚本,能直接拿过来用。

    后台运行配置
    1、基于软连接
    ①在pom.xml中添加Spring Boot的插件,并注意设置executable配置
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <executable>true</executable>
                </configuration>
            </plugin>
        </plugins>
    </build>
    ②mvn install进行打包,构建一个可执行的jar包
    ③创建软连接到/etc/init.d/目录下:
        sudo ln -s /usr/microservice/demo/demo-0.0.1-SNAPSHOT.jar /etc/init.d/demoapp
    ④在完成软连接创建之后,我们就可以通过如下命令对yourapp.jar应用来控制启动、停止、重启操作了
        /etc/init.d/demoapp start
    ⑤出现拒绝时:-bash: /etc/init.d/demoapp: Permission denied,
    可以通过——chmod a+x /etc/init.d/demoapp添加权限;
    其中a+x 是给所有人加上可执行权限,包括所有者,所属组,和其他人
    
    2、基于nohup
    nohup java -jar yourapp.jar &

     

    展开全文
  • Spring-boot 使用RestTemplate进行后台自动登录登录流程主要代码 内容不限于登录业务,主要简单介绍RestTemplate的用法,包括 使用RestTemplate进行post请求 postForObject 使用RestTemplate带body/form-data进行...

    Spring-boot 使用RestTemplate进行后台自动登录


    内容不限于登录业务,主要简单介绍 RestTemplate的用法,包括

    • 使用RestTemplate进行post请求 postForObject
    • 使用RestTemplate带body/form-data进行post请求 MultiValueMap
    • 使用RestTemplate带josn进行post请求JSONObject
    • 使用RestTemplate带头信息headers进行post请求 HttpHeaders

    登录流程

    • 定义 RestTemplate
    • 定义 MultiValueMap,构造 post的body内容
    • 定义 HttpHeaders,构造请求的头部信息
    • 定义 HttpEntity,发送请求的实体
    • 定义 RestTemplate,进行请求。返回数据

    主要代码

    	
    	// 构造 post的body内容(要post的内容,按需定义)
        MultiValueMap<String, String> paramsMap = new LinkedMultiValueMap<>();
    	paramsMap.set("grant_type", "password");
    	paramsMap.set("username", "yourname");
    	paramsMap.set("password", "yourpassword");
    
    	// 构造头部信息(若有需要)
        HttpHeaders headers = new HttpHeaders();
        headers.add("Authorization", "Basic xxxxxx你的认证密钥");
        // 设置类型 "application/json;charset=UTF-8"
        headers.setContentType(MediaType.APPLICATION_JSON); 
    	
    	// 构造请求的实体。包含body和headers的内容
    	HttpEntity<MultiValueMap<String, String>> request = new HttpEntity(paramsMap, headers);
        
        // 声明 restTemplateAuth(用作请求)
    	RestTemplate restTemplateAuth = new RestTemplate(); 
    	// 进行请求,并返回数据 
        String authInfo = restTemplateAuth.postForObject("http://localhost:8089/oauth/token", request, String.class);
    
    

    使用josn请求的示例代码
    Posting JSON with postForObject

    	JSONObject personJsonObject = new JSONObject();
        personJsonObject.put("id", 1);
        personJsonObject.put("name", "John");
    
    	HttpEntity<String> request = new HttpEntity<String>(personJsonObject.toString(), headers);
        String personResultAsJsonStr = restTemplate.postForObject("url", request, String.class);
    
    展开全文
  • spring-boot-plus是一套集成spring boot常用开发组件的后台快速开发框架。是易于使用,快速,高效,功能丰富,开源的spring boot脚手架。 spring-boot-plus前后端分离的框架,可以让用户专注于后端服务。 spring-...
  • Spring Boot Application后台守护Daemon应用

    千次阅读 2018-08-10 16:42:51
    在系统基于Spring Boot来构建Web应用之后,其实Spring Boot对于应用的支持同样非常的好,但是在程序其中之后,则程序自动就退出了,这个是什么情况? 系统的日志如下: 2018-08-10 16:38:29.525 INFO 12068 ---...

    问题的提出

    在系统基于Spring Boot来构建Web应用之后,其实Spring Boot对于应用的支持同样非常的好,但是在程序其中之后,则程序自动就退出了,这个是什么情况?
    系统的日志如下:

    
    2018-08-10 16:38:29.525  INFO 12068 --- [  restartedMain] org.config.test.App1Application          : Starting App1Application on ZB-PF0V10MN with PID 12068 (D:\sourcespace\app1\target\classes started by chenjunfeng1 in D:\sourcespace\app1)
    2018-08-10 16:38:29.526  INFO 12068 --- [  restartedMain] org.config.test.App1Application          : No active profile set, falling back to default profiles: default
    2018-08-10 16:38:29.621  INFO 12068 --- [  restartedMain] s.c.a.AnnotationConfigApplicationContext : Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@747d33e8: startup date [Fri Aug 10 16:38:29 CST 2018]; root of context hierarchy
    2018-08-10 16:38:30.457  INFO 12068 --- [  restartedMain] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729
    2018-08-10 16:38:30.478  INFO 12068 --- [  restartedMain] o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
    2018-08-10 16:38:30.520  INFO 12068 --- [  restartedMain] org.config.test.App1Application          : Started App1Application in 1.987 seconds (JVM running for 4.342)
    2018-08-10 16:38:30.539  INFO 12068 --- [       Thread-8] s.c.a.AnnotationConfigApplicationContext : Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@747d33e8: startup date [Fri Aug 10 16:38:29 CST 2018]; root of context hierarchy
    2018-08-10 16:38:30.545  INFO 12068 --- [       Thread-8] o.s.j.e.a.AnnotationMBeanExporter        : Unregistering JMX-exposed beans on shutdown

    程序在启动之后,自动退出了。

    问题分析

    对于应用来说,无需监听,在执行完任务之后,就自动退出,这个是非常正常的情况。那该如何做才能在后台让其一直运行呢?
    办法也很简单,就是利用Thread.joni()功能来实现,让主线程等待当前线程的退出,但是当前线程一直执行下去,不退出,则可以形成一个监听状态的应用。
    应用代码如下:

    import org.springframework.boot.CommandLineRunner;
    import org.springframework.stereotype.Component;
    
    @Component
    public class MyCMDLine implements CommandLineRunner {
        @Override
        public void run(String... args) throws Exception {
            Thread.currentThread().join();
        }
    }

    总结

    这个CommandLineRunner还可以接收来自启动命令和控制台的输入信息,并针对这些参数,将应用做出相应的调整。

    展开全文
  • JWT结合Spring Security实现登录spring security的配置 SecurityConfig@Override protected void configure(HttpSecurity http) throws Exception { //跨站请求伪造禁用 http.csrf().disable(); // 基于token,...

    Spring Security实现登录


    spring security的配置

        SecurityConfig

    @Override
    protected void configure(HttpSecurity http) throws Exception {
       //跨站请求伪造禁用
       http.csrf().disable();
    
       // 基于token,所以不需要session
       http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
       //不需要校验的文件
       http.authorizeRequests()
             .antMatchers("/", "/*.html", "/favicon.ico", "/css/**", "/js/**", "/fonts/**", "/layui/**", "/img/**",
                   "/v2/api-docs/**", "/swagger-resources/**", "/webjars/**", "/pages/**", "/druid/**",
                   "/statics/**")
             .permitAll().anyRequest().authenticated();
       http.formLogin().loginPage("/login.html").loginProcessingUrl("/login")
             .successHandler(authenticationSuccessHandler).failureHandler(authenticationFailureHandler).and()
             .exceptionHandling().authenticationEntryPoint(authenticationEntryPoint);
       http.logout().logoutUrl("/logout").logoutSuccessHandler(logoutSuccessHandler);
       // 解决不允许显示在iframe的问题
       http.headers().frameOptions().disable();
       http.headers().cacheControl();
    
       http.addFilterBefore(tokenFilter, UsernamePasswordAuthenticationFilter.class);
    }
    
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
       auth.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder());
    }

        SecurityHandlerConfig(spring security处理器)

    /**
     * 登陆成功,返回token
     *
     */
    @Bean
    public AuthenticationSuccessHandler loginSuccessHandler() {
        return new AuthenticationSuccessHandler() {
            @Override
            public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
                LoginUser loginUser = (LoginUser) authentication.getPrincipal();
    
                Token token = tokenService.saveToken(loginUser);
                ResponseUtil.responseJson(httpServletResponse, HttpStatus.OK.value(),token);
    
            }
        };
    }
    
    /**
     * 登录失败
     */
    
    @Bean
    public AuthenticationFailureHandler loginFailureHandler() {
        return new AuthenticationFailureHandler() {
            @Override
            public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
                String msg = null;
                if (e instanceof BadCredentialsException) {
                    msg = "密码错误";
                } else {
                    msg = e.getMessage();
                }
                ResponseInfo info = new ResponseInfo(HttpStatus.UNAUTHORIZED.value() + "", msg);
                ResponseUtil.responseJson(httpServletResponse, HttpStatus.UNAUTHORIZED.value(), info);
            }
        };
    }
    
    /**
     * 未登录
     */
    @Bean
    public AuthenticationEntryPoint authenticationEntryPoint() {
        return new AuthenticationEntryPoint() {
            @Override
            public void commence(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
                ResponseInfo info = new ResponseInfo(HttpStatus.UNAUTHORIZED.value() + "", "请先登录");
                ResponseUtil.responseJson(httpServletResponse, HttpStatus.UNAUTHORIZED.value(), info);
            }
        };
    }
    
    /**
     * 退出处理
     */
    
    @Bean
    public LogoutSuccessHandler logoutSuccessHandler() {
        return new LogoutSuccessHandler() {
            @Override
            public void onLogoutSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
                ResponseInfo info = new ResponseInfo(HttpStatus.OK.value() + "", "退出成功");
    
                String token = TokenFilter.getToken(httpServletRequest);
                tokenService.deleteToken(token);
                ResponseUtil.responseJson(httpServletResponse,HttpStatus.OK.value(),info);
            }
        };
    }

    Token拦截器

    @Component
    public class TokenFilter extends OncePerRequestFilter {
        private static final String TOKEN_KEY = "token";
        private static final Long MINUTES_10 = 10 * 60 * 1000L;
        @Autowired
        private TokenService tokenService;
    
        @Autowired
        private UserDetailsService userDetailsService;
    
        @Override
        protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
    
            String token = getToken(request);
            if (StringUtils.isBlank(token)) {
                LoginUser loginUser = tokenService.getLoginUser(token);
                if (loginUser != null) {
                    loginUser = checkLoginTime(loginUser);
                    UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(loginUser, null, loginUser.getAuthorities());
                    SecurityContextHolder.getContext().setAuthentication(authenticationToken);
                }
            }
    
            filterChain.doFilter(request,response);
    
        }
    
        /**
         * 校验过期时间
         * 过期时间与当前时间对比,临近过期10分钟的话,自动刷新缓存
         *
         * @return
         */
    
        private LoginUser checkLoginTime(LoginUser loginUser) {
            long expireTime = loginUser.getExpireTime();
            long currentTime = System.currentTimeMillis();
            if (expireTime - currentTime <= MINUTES_10) {
                String token = loginUser.getToken();
                loginUser = (LoginUser) userDetailsService.loadUserByUsername(loginUser.getUsername());
                loginUser.setToken(token);
                tokenService.refresh(loginUser);
            }
            return loginUser;
        }
    
        /**
         * 根据参数或者header获得token
         * @param request
         * @return
         */
    
        public static String getToken(HttpServletRequest request) {
            String token = request.getParameter(TOKEN_KEY);
            if (StringUtils.isBlank(token)) {
                token = request.getHeader(TOKEN_KEY);
            }
            return token;
        }
    }

    对token进行验证拦截

    具体实现

    前端调用登录方法

    function login(obj) {
       $(obj).attr("disabled", true);
    
       var username = $.trim($('#username').val());
       var password = $.trim($('#password').val());
       if (username == "" || password == "") {
          $("#info").html('用户名或者密码不能为空');
          $(obj).attr("disabled", false);
       } else {
          $.ajax({
             type : 'post',
             url : '/login',
             data : $("#login-form").serialize(),
             success : function(data) {
                localStorage.setItem("token", data.token);
                location.href = '/index.html';
             },
             error : function(xhr, textStatus, errorThrown) {
                var msg = xhr.responseText;
                var response = JSON.parse(msg);
                $("#info").html(response.message);
                $(obj).attr("disabled", false);
             }
          });
    
       }
    }

    因为在这里我们配置了登录请求这里被拦截下来了。

    http.formLogin().loginPage("/login.html").loginProcessingUrl("/login")
          .successHandler(authenticationSuccessHandler).failureHandler(authenticationFailureHandler).and()
          .exceptionHandling().authenticationEntryPoint(authenticationEntryPoint);

    后经过

    org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter

    这个拦截器的attemptAuthentication方法获取到前端的用户名和密码

     public UsernamePasswordAuthenticationFilter() {
            super(new AntPathRequestMatcher("/login", "POST"));
        }
    
        public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
            if (this.postOnly && !request.getMethod().equals("POST")) {
                throw new AuthenticationServiceException("Authentication method not supported: " + request.getMethod());
            } else {
                String username = this.obtainUsername(request);
                String password = this.obtainPassword(request);
                if (username == null) {
                    username = "";
                }
    
                if (password == null) {
                    password = "";
                }
    
                username = username.trim();
                UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(username, password);
                this.setDetails(request, authRequest);
                return this.getAuthenticationManager().authenticate(authRequest);
            }
        }

    该方法只支持post请求,获取到用户名密码后构造未认证的UsernamePasswordAuthentication 后设置details然后通过AuthenticationManager(实际上为ProviderManager的authenticate方法)完成验证

     public Authentication authenticate(Authentication authentication) throws AuthenticationException {
            Class<? extends Authentication> toTest = authentication.getClass();
            AuthenticationException lastException = null;
            Authentication result = null;
            boolean debug = logger.isDebugEnabled();
            Iterator var6 = this.getProviders().iterator();
    
            while(var6.hasNext()) {
                AuthenticationProvider provider = (AuthenticationProvider)var6.next();
                if (provider.supports(toTest)) {
                    if (debug) {
                        logger.debug("Authentication attempt using " + provider.getClass().getName());
                    }
    
                    try {
                        result = provider.authenticate(authentication);
                        if (result != null) {
                            this.copyDetails(authentication, result);
                            break;
                        }
                    } catch (AccountStatusException var11) {
                        this.prepareException(var11, authentication);
                        throw var11;
                    } catch (InternalAuthenticationServiceException var12) {
                        this.prepareException(var12, authentication);
                        throw var12;
                    } catch (AuthenticationException var13) {
                        lastException = var13;
                    }
                }
            }
    
            if (result == null && this.parent != null) {
                try {
                    result = this.parent.authenticate(authentication);
                } catch (ProviderNotFoundException var9) {
                    ;
                } catch (AuthenticationException var10) {
                    lastException = var10;
                }
            }
    
            if (result != null) {
                if (this.eraseCredentialsAfterAuthentication && result instanceof CredentialsContainer) {
                    ((CredentialsContainer)result).eraseCredentials();
                }
    
                this.eventPublisher.publishAuthenticationSuccess(result);
                return result;
            } else {
                if (lastException == null) {
                    lastException = new ProviderNotFoundException(this.messages.getMessage("ProviderManager.providerNotFound", new Object[]{toTest.getName()}, "No AuthenticationProvider found for {0}"));
                }
    
                this.prepareException((AuthenticationException)lastException, authentication);
                throw lastException;
            }
        }

        该方法先循环遍历provider 找到具体执行该认证的provider 然后复制details 然后由具体的provider来完成认证

        

        具体的验证处理由DaoAuthenticationProvider的父类AbstractUserDetailsAuthenticationProvider的authenticate方法来完成

    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
            Assert.isInstanceOf(UsernamePasswordAuthenticationToken.class, authentication, this.messages.getMessage("AbstractUserDetailsAuthenticationProvider.onlySupports", "Only UsernamePasswordAuthenticationToken is supported"));
            String username = authentication.getPrincipal() == null ? "NONE_PROVIDED" : authentication.getName();
            boolean cacheWasUsed = true;
            UserDetails user = this.userCache.getUserFromCache(username);
            if (user == null) {
                cacheWasUsed = false;
    
                try {
                    user = this.retrieveUser(username, (UsernamePasswordAuthenticationToken)authentication);
                } catch (UsernameNotFoundException var6) {
                    this.logger.debug("User '" + username + "' not found");
                    if (this.hideUserNotFoundExceptions) {
                        throw new BadCredentialsException(this.messages.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
                    }
    
                    throw var6;
                }
    
                Assert.notNull(user, "retrieveUser returned null - a violation of the interface contract");
            }
    
            try {
                this.preAuthenticationChecks.check(user);
                this.additionalAuthenticationChecks(user, (UsernamePasswordAuthenticationToken)authentication);
            } catch (AuthenticationException var7) {
                if (!cacheWasUsed) {
                    throw var7;
                }
    
                cacheWasUsed = false;
                user = this.retrieveUser(username, (UsernamePasswordAuthenticationToken)authentication);
                this.preAuthenticationChecks.check(user);
                this.additionalAuthenticationChecks(user, (UsernamePasswordAuthenticationToken)authentication);
            }
    
            this.postAuthenticationChecks.check(user);
            if (!cacheWasUsed) {
                this.userCache.putUserInCache(user);
            }
    
            Object principalToReturn = user;
            if (this.forcePrincipalAsString) {
                principalToReturn = user.getUsername();
            }
    
            return this.createSuccessAuthentication(principalToReturn, authentication, user);
        }

            该方法先获取到登录的用户名,如果缓存中有UserDetails则从缓存中获取UserDetails如果没有则根据用户名和authentication获取UserDetails 后进行一系列验证成功后返回Authentication

    验证过程由DaoAuthenticationProvider的retrieveUser和additionalAuthenticationChecks方法来实现

     protected final UserDetails retrieveUser(String username, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
            this.prepareTimingAttackProtection();
    
            try {
                UserDetails loadedUser = this.getUserDetailsService().loadUserByUsername(username);
                if (loadedUser == null) {
                    throw new InternalAuthenticationServiceException("UserDetailsService returned null, which is an interface contract violation");
                } else {
                    return loadedUser;
                }
            } catch (UsernameNotFoundException var4) {
                this.mitigateAgainstTimingAttack(authentication);
                throw var4;
            } catch (InternalAuthenticationServiceException var5) {
                throw var5;
            } catch (Exception var6) {
                throw new InternalAuthenticationServiceException(var6.getMessage(), var6);
            }
        }
     protected void additionalAuthenticationChecks(UserDetails userDetails, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
            if (authentication.getCredentials() == null) {
                this.logger.debug("Authentication failed: no credentials provided");
                throw new BadCredentialsException(this.messages.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
            } else {
                String presentedPassword = authentication.getCredentials().toString();
                if (!this.passwordEncoder.matches(presentedPassword, userDetails.getPassword())) {
                    this.logger.debug("Authentication failed: password does not match stored value");
                    throw new BadCredentialsException(this.messages.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
                }
            }
        }

        这个方法通过loadUserByUsername来获取到数据库中的用户信息,所以我们要自己重写实现UserDetailsService接口的loadUserByUsername方法

    @Service
    public class UserDetailsServiceImpl implements UserDetailsService{
    
    
        @Autowired
        private UserService userService;
        @Autowired
        private PermissionDao permissionDao;
    
    
        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    
            SysUser user = userService.getUser(username);
            if (user == null) {
                throw new AuthenticationCredentialsNotFoundException("用户名不存在");
            } else if (user.getStatus() == Status.LOCKED) {
                throw new LockedException("用户被锁定,请联系管理员");
            } else if (user.getStatus() == Status.DISABLED) {
                throw new DisabledException("用户已被封禁");
            }
    
            LoginUser loginUser = new LoginUser();
            BeanUtils.copyProperties(user, loginUser);
    
            List<Permission> permissions = permissionDao.listByUserId(user.getId());
            loginUser.setPermissions(permissions);
    
            return loginUser;
        }
    }

    通过loadUserByUsername获取到数据库的用户信息在通过上面的两个方法和前端传过来的用户信息进行比对就完成了登录认证。

    认证完成后成功失败等一系列处理在SecurityHandlerConfig进行处理,成功后将token储存到redis中。

    展开全文
  • spring boot结合spring security实现用户注册后自动登录 在开发过程中,有些页面只有用户登录之后才能访问,比如用户的个人中心,但是按道理用户注册之后也应该有权限进入了个人中心,下面即是实现用户注册后自动...
  • spring boot jar 进程自动停止,自动终止,不能后台持续运行 第一次部署spring boot 到linux上,用命令java -jar **.jar,发现应用自动退出,进程停止了。后来发现要不挂断的执行命令,忽略所有的挂断信号,用以下...
  • Spring Boot自动扫描

    千次阅读 2019-09-05 22:03:35
    进行Spring Boot和Mybatis进行整合的时候,SpringBoot注解扫描的时候无法扫描到Application类的以外的包下面的注解,如下图: App就是Application类,下图是ProductMapper 类: @Mapper public interface ...
  • Spring Boot 项目自动发布与Supervisor

    千次阅读 2018-06-01 16:59:23
    Spring Boot 项目自动发布与Supervisor 前面写了一遍关于Spring Boot项目自动发布的文章,这里是Github地址。 还是受到不少欢迎的,有不少点赞的朋友,这次再接再厉,跟着上一篇,介绍使用Supervisor管理Spring ...
  • spring boot使用的过程中, 发现我修改了静态文件, 前台刷新后, 没有任何变化, 必须重新启动, 才能看到, 这简直不能让人接受. 那有什么方法来解决这个问题呢. Baidu之后, 得到了想要的答案, 在这里记录下来. ...
  • spring-boot-plus是一套集成spring boot常用开发组件的后台快速开发框架 官网地址:springboot.plus GITHUB:https://github.com/geekidea/spring-boot-plus GITEE:https://gitee.com/geekidea/spring-boot-plus ...
  • 最近要实现一个基于Spring boot后台管理平台,在慕课网上看到了Allen_jiang老师的基于Spring boot十分钟搞定后台管理平台,为了总结一下,顺便也记录一下,便于以后复习。在这里附上老师的教程网址:...
  • 史上最全Spring Boot面试题(含答案)看完就是Spring Boot专家! 一.Spring BootSpring MVC 和 Spring 有什么区别? SpringFrame SpringFramework 最重要的特征是依赖注入。所有 SpringModules 不是依赖注入...
  • 一、Spring MVC 自动配置 SpringBoot实现自定义...一般自动配置类功能的实现,会先判断容器中是否存在相关类,如果不存在才是用Spring Boot中默认的自动配置类 SpringMVC执行流程: Spring MVC Auto-configuration ...
  • JavaWeb_v1.0.0专业版,企业级开发框架SpringBoot+Layui+Thymeleaf+MybatisPlus开发权限(RBAC)及内容管理框架,框架中集成了权限管理、模块管理,数据库管理、富文本编辑器(已集成ueditor,kindeditor),后台支持多主题...
  • Guns基于SpringBoot,致力于做更简洁的后台管理系统,完美整合springmvc + shiro + mybatis-plus + beetl + flowable!Guns项目代码简洁,注释丰富,上手容易,同时Guns包含许多基础模块(用户管理,角色管理,部门管理,字典...
  • spring-boot-plus在mybatis-plus基础上,新增param/vo等模板 拓展controller/service/mapper/xml方法 Purpose 数据库新建表,即可生成后台CRUD/分页基础代码,还有swagger! 官网地址:springboot.plus GITHUB:...
  • spring boot配置druid监控后台监控

    千次阅读 2020-07-13 16:35:17
    org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.8.RELEASE</version> <relativePath/> <!-- looku
  • https://www.cnblogs.com/elvinle/p/7989119.html http://blog.csdn.net/je_ge/article/details/53326525
  • 我使用的是Ajax前端传数据给用Spring boot框架搭的后台后台可以接受到数据,但是返回到前端时不能进入Ajax的success的函数里面,而是执行的error函数里的内容。 前端Ajax代码 //点击事件,当前端的标签被点击...
  • Spring Boot 自动配置数据源

    千次阅读 2019-10-27 12:12:43
    Spring Boot 自动配置数据源 SpringBoot连接数据库无论是关系型数据库mysql、 oracle 还是非关系型数据库redis 、mongdb等都非常方便,只需要在配置文件中添加需要的配置信息,在pom中添加相应的数据库starter启动...
  • 本项目使用 Spring Boot 搭建, 用于加深对 Spring Boot 与 Shiro 的学习, 项目特色是支持 restful 风格权限控制, 支持对同一 URL, 不同 HTTP Mehtod 的权限控制, 适用于更多的场景. 预览地址: http://ewt.186g.cn ...
  • spring boot

    2020-08-25 11:28:29
    Spring Boot是由Pivotal团队提供的全新框架,其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置,从而使开发人员不再需要定义样板化的配置。通过这种方式,Spring Boot...
  • 使用Spring Boot开发Web项目

    万次阅读 多人点赞 2016-12-21 17:26:31
    前面两篇博客中我们简单介绍了Spring Boot项目的创建、并且也带小伙伴们来DIY了一个Spring Boot自动配置功能,那么这些东西说到底最终还是要回归到Web上才能体现出它的更大的价值,so,今天我们就来看一下如何使用...
  • 搭建spring-boot+vue前后端分离框架并实现登录功能

    万次阅读 多人点赞 2018-08-12 12:17:01
    源码链接:... 一、环境、工具 jdk1.8 maven spring-boot ...二、搭建后台spring-boot框架 步骤: 1、new-project选择SpringInitializr next 2、创建项目文件结构以...
  • 年初公司计划要上一个产品,而且是要在两周内上线(由于之前已经开发、运营过一个类似的产品,所以这次要求先将核心功能上线;当然最后没有那么快上线,这... 技术方案决定使用spring boot 后,大家分工开始各自各干各

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,679
精华内容 10,671
关键字:

bootspring自动后台登录

spring 订阅