springboot项目功能之security结合springjpa实现登录(很好用)

最新推荐文章于 2024-06-28 16:28:01 发布
最新推荐文章于 2024-06-28 16:28:01 发布
阅读量269 收藏
点赞数
分类专栏： springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42794826/article/details/117220311
版权

Spring Boot Spring Security 权限管理 数据库 UserDetailsService
关键词由CSDN通过智能技术生成

前言

登录权限问题在需求中很常见的,比如qq有很多会员,每个会员的有很多不同的权限,

步骤一

基本配置
1.引入依赖

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>



        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.54</version>
        </dependency>


<!--        redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.4.10.Final</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.0.0</version>
        </dependency>

2.重写这个类 解决SpringDataJpa实体类中属性顺序与数据库中生成字段顺序不一致的问题
在这里插入图片描述

/**
 * 解决SpringDataJpa实体类中属性顺序与数据库中生成字段顺序不一致的问题 */
class PropertyContainer {
    private static final CoreMessageLogger LOG = (CoreMessageLogger)Logger.getMessageLogger(CoreMessageLogger.class, PropertyContainer.class.getName());
    private final XClass xClass;
    private final XClass entityAtStake;
    private final AccessType classLevelAccessType;
    private final LinkedHashMap<String, XProperty> persistentAttributeMap;

    PropertyContainer(XClass clazz, XClass entityAtStake, AccessType defaultClassLevelAccessType) {
        this.xClass = clazz;
        this.entityAtStake = entityAtStake;
        if (defaultClassLevelAccessType == AccessType.DEFAULT) {
            defaultClassLevelAccessType = AccessType.PROPERTY;
        }

        AccessType localClassLevelAccessType = this.determineLocalClassDefinedAccessStrategy();

        assert localClassLevelAccessType != null;

        this.classLevelAccessType = localClassLevelAccessType != AccessType.DEFAULT ? localClassLevelAccessType : defaultClassLevelAccessType;

        assert this.classLevelAccessType == AccessType.FIELD || this.classLevelAccessType == AccessType.PROPERTY;

        this.persistentAttributeMap = new LinkedHashMap<>();
        List<XProperty> fields = this.xClass.getDeclaredProperties(AccessType.FIELD.getType());
        List<XProperty> getters = this.xClass.getDeclaredProperties(AccessType.PROPERTY.getType());
        this.preFilter(fields, getters);
        Map<String, XProperty> persistentAttributesFromGetters = new HashMap();
        this.collectPersistentAttributesUsingLocalAccessType(this.persistentAttributeMap, persistentAttributesFromGetters, fields, getters);
        this.collectPersistentAttributesUsingClassLevelAccessType(this.persistentAttributeMap, persistentAttributesFromGetters, fields, getters);
    }

    private void preFilter(List<XProperty> fields, List<XProperty> getters) {
        Iterator propertyIterator = fields.iterator();

        XProperty property;
        while(propertyIterator.hasNext()) {
            property = (XProperty)propertyIterator.next();
            if (mustBeSkipped(property)) {
                propertyIterator.remove();
            }
        }

        propertyIterator = getters.iterator();

        while(propertyIterator.hasNext()) {
            property = (XProperty)propertyIterator.next();
            if (mustBeSkipped(property)) {
                propertyIterator.remove();
            }
        }

    }

    private void collectPersistentAttributesUsingLocalAccessType(LinkedHashMap<String, XProperty> persistentAttributeMap, Map<String, XProperty> persistentAttributesFromGetters, List<XProperty> fields, List<XProperty> getters) {
        Iterator propertyIterator = fields.iterator();

        XProperty xProperty;
        Access localAccessAnnotation;
        while(propertyIterator.hasNext()) {
            xProperty = (XProperty)propertyIterator.next();
            localAccessAnnotation = (Access)xProperty.getAnnotation(Access.class);
            if (localAccessAnnotation != null && localAccessAnnotation.value() == javax.persistence.AccessType.FIELD) {
                propertyIterator.remove();
                persistentAttributeMap.put(xProperty.getName(), xProperty);
            }
        }

        propertyIterator = getters.iterator();

        while(propertyIterator.hasNext()) {
            xProperty = (XProperty)propertyIterator.next();
            localAccessAnnotation = (Access)xProperty.getAnnotation(Access.class);
            if (localAccessAnnotation != null && localAccessAnnotation.value() == javax.persistence.AccessType.PROPERTY) {
                propertyIterator.remove();
                String name = xProperty.getName();
                XProperty previous = (XProperty)persistentAttributesFromGetters.get(name);
                if (previous != null) {
                    throw new MappingException(LOG.ambiguousPropertyMethods(this.xClass.getName(), HCANNHelper.annotatedElementSignature(previous), HCANNHelper.annotatedElementSignature(xProperty)), new Origin(SourceType.ANNOTATION, this.xClass.getName()));
                }

                persistentAttributeMap.put(name, xProperty);
                persistentAttributesFromGetters.put(name, xProperty);
            }
        }

    }

    private void collectPersistentAttributesUsingClassLevelAccessType(LinkedHashMap<String, XProperty> persistentAttributeMap, Map<String, XProperty> persistentAttributesFromGetters, List<XProperty> fields, List<XProperty> getters) {
        Iterator var5;
        XProperty getter;
        if (this.classLevelAccessType == AccessType.FIELD) {
            var5 = fields.iterator();

            while(var5.hasNext()) {
                getter = (XProperty)var5.next();
                if (!persistentAttributeMap.containsKey(getter.getName())) {
                    persistentAttributeMap.put(getter.getName(), getter);
                }
            }
        } else {
            var5 = getters.iterator();

            while(var5.hasNext()) {
                getter = (XProperty)var5.next();
                String name = getter.getName();
                XProperty previous = (XProperty)persistentAttributesFromGetters.get(name);
                if (previous != null) {
                    throw new MappingException(LOG.ambiguousPropertyMethods(this.xClass.getName(), HCANNHelper.annotatedElementSignature(previous), HCANNHelper.annotatedElementSignature(getter)), new Origin(SourceType.ANNOTATION, this.xClass.getName()));
                }

                if (!persistentAttributeMap.containsKey(name)) {
                    persistentAttributeMap.put(getter.getName(), getter);
                    persistentAttributesFromGetters.put(name, getter);
                }
            }
        }

    }

    public XClass getEntityAtStake() {
        return this.entityAtStake;
    }

    public XClass getDeclaringClass() {
        return this.xClass;
    }

    public AccessType getClassLevelAccessType() {
        return this.classLevelAccessType;
    }

    public Collection<XProperty> getProperties() {
        this.assertTypesAreResolvable();
        return Collections.unmodifiableCollection(this.persistentAttributeMap.values());
    }

    private void assertTypesAreResolvable() {
        Iterator var1 = this.persistentAttributeMap.values().iterator();

        XProperty xProperty;
        do {
            if (!var1.hasNext()) {
                return;
            }

            xProperty = (XProperty)var1.next();
        } while(xProperty.isTypeResolved() || discoverTypeWithoutReflection(xProperty));

        String msg = "Property " + StringHelper.qualify(this.xClass.getName(), xProperty.getName()) + " has an unbound type and no explicit target entity. Resolve this Generic usage issue or set an explicit target attribute (eg @OneToMany(target=) or use an explicit @Type";
        throw new AnnotationException(msg);
    }

    private AccessType determineLocalClassDefinedAccessStrategy() {
        AccessType hibernateDefinedAccessType = AccessType.DEFAULT;
        AccessType jpaDefinedAccessType = AccessType.DEFAULT;
        org.hibernate.annotations.AccessType accessType = (org.hibernate.annotations.AccessType)this.xClass.getAnnotation(org.hibernate.annotations.AccessType.class);
        if (accessType != null) {
            hibernateDefinedAccessType = AccessType.getAccessStrategy(accessType.value());
        }

        Access access = (Access)this.xClass.getAnnotation(Access.class);
        if (access != null) {
            jpaDefinedAccessType = AccessType.getAccessStrategy(access.value());
        }

        if (hibernateDefinedAccessType != AccessType.DEFAULT && jpaDefinedAccessType != AccessType.DEFAULT && hibernateDefinedAccessType != jpaDefinedAccessType) {
            throw new org.hibernate.MappingException("@AccessType and @Access specified with contradicting values. Use of @Access only is recommended. ");
        } else {
            AccessType classDefinedAccessType;
            if (hibernateDefinedAccessType != AccessType.DEFAULT) {
                classDefinedAccessType = hibernateDefinedAccessType;
            } else {
                classDefinedAccessType = jpaDefinedAccessType;
            }

            return classDefinedAccessType;
        }
    }

    private static boolean discoverTypeWithoutReflection(XProperty p) {
        if (p.isAnnotationPresent(OneToOne.class) && !((OneToOne)p.getAnnotation(OneToOne.class)).targetEntity().equals(Void.TYPE)) {
            return true;
        } else if (p.isAnnotationPresent(OneToMany.class) && !((OneToMany)p.getAnnotation(OneToMany.class)).targetEntity().equals(Void.TYPE)) {
            return true;
        } else if (p.isAnnotationPresent(ManyToOne.class) && !((ManyToOne)p.getAnnotation(ManyToOne.class)).targetEntity().equals(Void.TYPE)) {
            return true;
        } else if (p.isAnnotationPresent(ManyToMany.class) && !((ManyToMany)p.getAnnotation(ManyToMany.class)).targetEntity().equals(Void.TYPE)) {
            return true;
        } else if (p.isAnnotationPresent(Any.class)) {
            return true;
        } else if (p.isAnnotationPresent(ManyToAny.class)) {
            if (!p.isCollection() && !p.isArray()) {
                throw new AnnotationException("@ManyToAny used on a non collection non array property: " + p.getName());
            } else {
                return true;
            }
        } else if (p.isAnnotationPresent(Type.class)) {
            return true;
        } else {
            return p.isAnnotationPresent(Target.class);
        }
    }

    private static boolean mustBeSkipped(XProperty property) {
        return property.isAnnotationPresent(Transient.class) || "net.sf.cglib.transform.impl.InterceptFieldCallback".equals(property.getType().getName()) || "org.hibernate.bytecode.internal.javassist.FieldHandler".equals(property.getType().getName());
    }
}

3.application.yml配置数据库和jpa

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql:///你的数据库
    username: root
    password: *****

  jpa:
    database: mysql
    show-sql: true
    hibernate:
      ddl-auto: update
      naming:
        physical-strategy: org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy

步骤二

配置security的配置类
设置权限分配

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
@Order(-1)
public class MyWebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserService userService;


    @Bean
    PasswordEncoder passwordEncoder(){

        return new BCryptPasswordEncoder(10);
    }

    /**
     * 不使用数据库
     * @param http
     * @throws Exception
     */

//    @Override
//    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
//        auth.inMemoryAuthentication()
//                .withUser("admin").password("$2a$10$U3EkVjomZM2YJ/E3weONZO2H4Zm7K0hB6hgPiqhUv73vxXx92M/ne").roles("ADMIN","USER")
//                .and()
//                .withUser("sang").password("$2a$10$QcJ7zeDeqJQh/ZNt08x4xuvHy4utVMvmbzcsKNvtF.SxAXOgq.k2C").roles("USER");
//    }



    /**
     * 使用数据库
     * @throws Exception
     */

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userService);
    }


    /*
    当已经认证过的用户尝试再次认证时，应用针对该事件有几种处理方式。
    可以注销当前用户session，使用新的session重新认证，或允许两个session并存。
     */

//    @Bean
//    public HttpSessionEventPublisher httpSessionEventPublisher() {
//        return new HttpSessionEventPublisher();
//    }


    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //先配置session
        http.sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED)
                .and()
                .authorizeRequests()
                .antMatchers("/admin/**")
                .hasRole("admin")
                .antMatchers("/db/**")
                .access("hasRole('admin') and hasRole('dba')")
                .anyRequest()
                //必须认证访问
//                .authenticated()


                .permitAll()

                .and()
                .formLogin()
                .loginPage("/login_page")
                .loginProcessingUrl("/login")
                .usernameParameter("user")
                .passwordParameter("passwd")
                .successHandler(new AuthenticationSuccessHandler() {
                    @Override
                    public void onAuthenticationSuccess(HttpServletRequest req, HttpServletResponse resp, Authentication auth) throws IOException, ServletException {
                        Object principal =auth.getPrincipal();
                        resp.setContentType("application/json;charset=utf-8");
                        PrintWriter out = resp.getWriter();
                        HashMap<String, Object> map = new HashMap<>();
                        map.put("status",200);
                        map.put("msg", principal);
                        ObjectMapper om = new ObjectMapper();
                        out.write(om.writeValueAsString(map));
                        out.flush();
                        out.close();
                    }
                })
                .failureHandler(new AuthenticationFailureHandler() {
                    @Override
                    public void onAuthenticationFailure(HttpServletRequest req, HttpServletResponse resp, AuthenticationException e) throws IOException, ServletException {
                        resp.setContentType("application/json;charset=utf-8");
                        PrintWriter out = resp.getWriter();
                        HashMap<String, Object> map = new HashMap<>();
                        map.put("msg","没有权限");
                        map.put("status",400);
                        ObjectMapper om = new ObjectMapper();
                        out.write(om.writeValueAsString(map));
                        out.flush();
                        out.close();
                    }
                })
                .and()
                //对于没有配置权限的其他请求允许匿名访问
                .anonymous()
                .and()
                .logout()
                .logoutUrl("logout")
                //get请求
                .logoutRequestMatcher(new AntPathRequestMatcher("/logout", "GET"))
                .clearAuthentication(true)
                .invalidateHttpSession(true)
                .addLogoutHandler(new LogoutHandler() {
                    @Override
                    public void logout(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) {

                    }
                })
                .logoutSuccessHandler(new LogoutSuccessHandler() {
                    @Override
                    public void onLogoutSuccess(HttpServletRequest req, HttpServletResponse resp, Authentication authentication) throws IOException, ServletException {
                        PrintWriter writer = resp.getWriter();
                        req.setCharacterEncoding("utf-8");  // 设置request字符编码
                        String searchText = req.getParameter("search"); // 获取传入的search字段的内容
                        resp.setContentType("text/json; charset=utf-8");    // 设置response的编码及格式
                        PrintWriter out = resp.getWriter();
                        Map<String,Object> resMap = new HashMap<>();
                        //200成功  400代表失败
                        resMap.put("code",200);
                        String resJSON = JSON.toJSONString(resMap);     // 转换为json
                        out.print(resJSON);

                    }
                })
                .permitAll()
                .and()
                .cors()//新加入
                .and()
                .csrf()
                .disable();

    }

}

步骤三

首先创建实体类
User和Role
user

@Data
@Entity(name = "user")
public class User implements UserDetails , Serializable {

    private static final long serialVersionUID = -5470916854745278810L;


    @Id
    @Column(name = "id", columnDefinition = "varchar(255)")
    private String id;

    @Column(name = "username", columnDefinition = "varchar(255)")
    private String username;

    @Column(name = "password", columnDefinition = "varchar(255)")
    private String password;

    @Column(name = "enabled", columnDefinition = "boolean")
    private boolean enabled =true;

    @Column(name = "locked", columnDefinition = "boolean")
    private boolean locked =false;

    @ManyToMany(fetch = FetchType.EAGER, cascade = CascadeType.PERSIST)
    private List<Role> roles;


    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        List<SimpleGrantedAuthority> authorities = new ArrayList<>();
        for (Role role : getRoles()) {
            authorities.add(new SimpleGrantedAuthority(role.getName()));
        }
        return authorities;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return !locked;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }




    public User() {
    }


    public User(String id, String username, String password, boolean enabled, boolean locked, List<GrantedAuthority> roles) {

        this.id=id;
        this.username=username;
        this.password=password;
        this.enabled=enabled;
        this.locked=locked;

        List<Role> roleList=new ArrayList<>();

        roles.forEach(it->{
            Role role = new Role();
            role.setId(10L);
            role.setName(it.toString());
            role.setNameZh("测试权限");
            roleList.add(role);
        });


        this.roles=roleList;


    }

}

Role

@Data
@Entity(name = "role")
public class Role {

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;

	private String name;

	private String nameZh;

}

编写roleDao和userDao

public interface UserDao extends JpaRepository<User, Long> {

        User findUserByUsername(String username);
        

        User findUserById(String id);
    }

public interface RoleDao extends JpaRepository<Role, Long> {

    Role findRoleByName(String name);

}

实现UserDetailsService方法重写loadUserByUsername

@Service
public class UserService implements UserDetailsService {

    @Autowired
    UserDao userDao;

//    UserDetails
    /**
     * 根据用户名加载用户信息
     *
     * @param username 用户名
     * @return UserDetails
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userDao.findUserByUsername(username);
        //动态添加用户到数据库,然后登录

        if (user == null) {
            throw new UsernameNotFoundException("用户不存在");
        }
        return user;

    }

}

login和logout已经定义好了

最后实现注册的代码

/**
     * 注册一个用户
     * @return
     */

    @PostMapping("/register")
    public Map<String,Object> register(String user,String passwd){


//        System.out.println(user);
//        System.out.println(passwd);

//        默认添加admin的权限
        //添加默认的属性
        //然后

        User new_user =new User();
//
//
//
        new_user.setUsername(user);


        new_user.setId(uuidUtil.getUUID());


        String encode_pass = passwordEncoder.encode(passwd);

        new_user.setPassword(encode_pass);

        Role role_admin = roleDao.findRoleByName("ROLE_user");
//
//
//
//
        List<Role> list =new ArrayList<>();
//
        list.add(role_admin);
        list.add(role);
//
        new_user.setRoles(list);
//
        userDao.save(new_user);

//
        Map<String, Object> result = new HashMap<>();

        result.put("res",200);

        return result;

    }

这就整合完毕了,欢迎观看
点个赞再走呗~

小小雨伞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring jpa 自动建表 字段乱序 字段 顺序
weixin_34321753的博客
04-11 6500
2019独角兽企业重金招聘Python工程师标准>>> ...
解决 Springboot Jpa 自动创建表 和字段乱序问题[凤凰小哥哥]
09-20
产生原因：因为使用 jpa 自动创建表的时候，采用的是TreeMap的，我们要变成LinkedHashMap 的结构。 解决方案：在项目下java文件夹下创建包名为： org.hibernate.cfg  ，创建类： PropertyContainer [包名，类名一定要相同哦]
JPA自动创建表实体类和数据库表字段顺序不对应问题(已解决)
qq_42651201的博客
05-17 1349
1.在jar包中找到如下地址 在cfg文件下找到PropertyContainer类 2.在src目录下创建一样的包结构和类 3.复制以下全部代码到PropertyContainer类中，如果包位置和类名没没有错的话，复制下面的代码不用做任何改动即可使用，如果有错，请仔细检查。当然你也可以复制jar包中的源码，自己改。 package org.hibernate.cfg; import org.hibernate.AnnotationException; import org.hibernate.a
IDEA SpringBoot整合SpringData JPA（保姆级教程，超详细！！！）
最新发布
当觉得自己菜的时候，就应该静下心来学习
06-28 1957
本博客将详细介绍在IDEA中，如何整合SpringBoot与SpringData JPA，以实现数据库的增删改查操作。我将逐步从环境搭建到实际代码实现的完整流程，帮助读者更好地理解并掌握这一技术栈。JPA是Java Persistence API的缩写，它定义了Java对象如何映射到关系型数据库中的表，以及如何使用面向对象的方式来查询这些表。JPA是Java EE 5规范的一部分，并由EJB 3.0（Enterprise JavaBeans）实现。2. 创建SpringBoot项目。
Java jpa自动建表 危害,SpringDataJPA自动建表字段顺序优化
weixin_32801895的博客
03-11 903
JPA 自动建表字段顺序优化1、表字段顺序和实体类定义字段顺序一致原理：复制一个 hibernate 包下的 PropertyContainer 类，修改其中 persistentAttributeMap 的类型，TreeMap 修改为有序的 LinkedHashMap，在下次类加载时，会优先加载我们定义的类。2、自定义继承类字段顺序原理同上就不说了。一般我们的实体类会继承一个父类，父类中有 id...
spring data jpa 实体类中字段不与数据库表映射 ORA-00904 标识符无效
小楼一夜听春雨
10-31 2万+
当我们使用spring data jpa开发的时候，会将实体类中的成员变量与表中的字段一一对应，当我们在实体类中加上一个不与数据库表一一对应的成员变量的时候，此时会报错，例如： Caused by: java.sql.SQLSyntaxErrorException: ORA-00904: "BOOK0_"."TYPENAMES": 标识符无效 此时我们只要在这个成员变量上加上注解@Tr
SpringBoot + Thymeleaf + WebSocket + Spring Security + SpringData-Jpa
10-26
在这个项目中，SpringBoot作为基础框架，Thymeleaf处理视图渲染，WebSocket实现实时通信，Spring Security确保安全，SpringData-Jpa处理数据库操作，MySQL作为数据存储，而Layui则负责提供用户界面。这个组合可以...
springBoot登录注册功能的实现
04-12
在Spring Boot框架中实现登录注册功能是Web应用开发的基础，对于初学者来说，这是一个很好的学习起点。Spring Boot以其简洁的配置和快速的开发能力，深受开发者喜爱。在这里，我们将深入探讨如何利用Spring Boot来...
idea+springboot+MySQL+jdk1.8实现简单的注册登录功能
02-06
在本文中，我们将深入探讨如何使用IDEA、Spring Boot、MySQL和JDK 1.8来实现一个基本的用户注册和登录功能。这个项目对于初学者来说是一个很好的起点，因为它涵盖了现代Web应用开发中的核心技术和工具。 首先，让...
CoderGroup:基于 SpringBoot + Spring Data JPA + Spring Security + Thymeleaf 实现的开发者社区，目前支持博客和问答
05-08
CoderGroup 预览地址 效果图见下面 反馈地址： 有什么问题，可以加QQ群：590480292(开发者技术交流群) ...本项目使用的是 SpringBoot1.5.9 版本，起初用的是 SpringBoot 2.0,但是觉得还是会遇到很多问题
基于Springboot+SpringSecurity+Thymeleaf+Mysql的网上书城.zip
05-25
这个项目涵盖了Web开发中的许多关键概念和技术，对于学习Java Web开发的学生来说，它是一个很好的实践项目，可以帮助他们理解如何整合不同的技术组件，构建一个完整的、功能齐全的Web应用。同时，它也展示了现代化...
JPA注解 和hibernate 建表
07-07
JPA注解创建数据库表 和hibernate.cfg.xml 建表
03. Spring Security 之前后端分离
明月燃雨
12-27 428
1. 登录交互 1.1 登录成功回调 代码如下： .and() .formLogin() .loginPage("/login.html") .loginProcessingUrl("/login") .usernameParameter("name") .passwordParameter("pwd") .successHandler((request, response, authentication) -> { Object principal = authentication.getPrin
springboot整合security、jpa
qq_37705525的博客
06-12 478
springboot整合security、jpa
spring data jpa 实体类中字段不与数据库表映射
weixin_44423144的博客
02-03 2474
当我们使用spring data jpa开发的时候，当我们在实体类中加上一个不与数据库表一一对应的成员变量的时候，此时我们只要在这个成员变量上加上注解@Transient 注意是javax.persistence.Transient 　 而不是spring annotation包下的注解类。 @Transient private List<GrantedAuthority> autho...
使用Spring Security、Spring Data Jpa实现的RBAC权限控制
热门推荐
tanghuanyou---的博客
05-18 2万+
使用Spring Security、Spring Data Jpa做RBAC的权限控制。
Hibernate（JPA）中实体类变量与表中字段顺序不一致问题
cauchy6317的博客
08-27 3443
在使用JPA的过程，当使用spring.jpa.hibernate.ddl-auto=update属性时，我们是能在数据库中创建实体类所对应的表，但是却发现表中字段的顺序和实体类中变量的顺序不一致。作为一名爱思考（装b）的程序猿，我觉得是时候展现我真正的实力了。作为一名爱读源码的程序猿，我先打开了hibernate的源码包位置，如图： 接下来，就开始思考（Google），这么多我读个锤子哦。...
@NamedEntityGraphs --JPA按实体类对象参数中的字段排序问题得解决方法
weixin_30920513的博客
09-07 2149
JPA按实体类对象参数中的字段排序问题得解决方法@Entity @Table(name="complaints") @NamedEntityGraphs({ @NamedEntityGraph(name="allJoinsButMessages", attributeNodes = { @NamedAttributeNode("customer"), ...
Java@注解-JPA实体类与数据库对应
weixin_44177447的博客
06-11 2297
Springboot+Hibernate+JPA 1. 数据库和实体类同步： @Entity 只有一个属性name @Table 属性name 属性catalog 和 schema 用于设置表所属的数据库目录或模式，基本上用不到 2. @Id 设置主键 3. @GeneratedValue(strategy = GenerationType.AUTO) ，设置自增长，一般与@Id搭配使用 4. @Column： 当实体类的属性和数据库中的字段名称不一样时使用 如： @Column（name=“uid”
使用Spring-security+jwt+springboot+mysql+jpa或mybatisplus完成RBAC权限管理
04-25
很好的问题！使用Spring-security jwt、Spring Boot、MySQL以及JPA或MyBatis Plus来完成RBAC权限管理是可行的。RBAC（Role-Based Access Control）权限管理是一种广泛使用的准则，用于控制基于角色的权限访问。它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值