精华内容
下载资源
问答
  • 一些id标识的要求,比如数字自增,0001,0002,0003等。下面这个方法实现了这个功能: 思路:int a;a++;fillchar(); 贴代码: public class mainTest { public static void main(String[] args) { String ...

    一些id标识的要求,比如数字自增,0001,0002,0003等。下面这个方法实现了这个功能:

    思路:int a;a++;fillstr();

    贴代码:

    public class mainTest {
     
     public static void main(String[] args) {
      String outString="";
      outString=fillStr("123", 9, false, "0");
      System.out.println("false"+outString);
      outString=fillStr("123", 9, true, "0");
      System.out.println("true"+outString);
      
     }
     /**
      * 
      * @param value
      * @param count
      * @param frontORback 
      * @param fillChar
      * @return if frontORback is ture ,return the (count-value.length) fillchar added to the front of the value 
      * if frontORback is false,return the (count-value.length) fillchar added to the back of the value
      * for instance : value="123",count=9,frontORback=true,fillchar="0"<br>
      * return "123000000"
      *
      */
     private static String fillStr(String value, int count, boolean frontORback, String fillChar) {
         String rtvalue = value;
         if (rtvalue == null) {
          rtvalue = "";
          for (int i = 0; i < count; i++)
           if (frontORback)
            rtvalue = String.valueOf(rtvalue)
              + String.valueOf(fillChar);
           else
            rtvalue = String.valueOf(fillChar)
              + String.valueOf(rtvalue);
         } else {
          int len = rtvalue.length();
          if (len > count) {
           rtvalue = rtvalue.substring(0, count);
          } else {
           int a = count - len;
           for (int i = 0; i < a; i++)
            if (frontORback)
             rtvalue = String.valueOf(rtvalue)
               + String.valueOf(fillChar); 
            else
             rtvalue = String.valueOf(fillChar)
               + String.valueOf(rtvalue);
          }
         }
         return rtvalue;
        }
    }
    


     

    展开全文
  • java快速ID自增

    2018-09-21 18:00:27
    id自增,适用于快速,频繁产生自增ID,在spring配置数据源即可
  • java实现INT自增主键

    千次阅读 2020-06-18 18:47:08
    import java.io.*; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.atomic.AtomicInteger; import java.util.stream.Collectors; public class SnowIdUtils
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.io.*;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.atomic.AtomicInteger;
    import java.util.stream.Collectors;
    
    public class SnowIdUtils {
        private static Map<String, AtomicInteger> keyMap;
        private static final Logger logger = LoggerFactory.getLogger(SnowIdUtils.class);
    
        public static int idKey(String keyName) {
            AtomicInteger atomicInteger = keyMap.get(keyName);
            if (atomicInteger == null) {
                atomicInteger = new AtomicInteger(1);
                keyMap.put(keyName, atomicInteger);
            }
            return atomicInteger.getAndIncrement();
        }
    
        static {
            try {
                File file = new File(System.getProperty("user.dir") + "/snow.txt");
                if (file.exists()) {
                    BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
                    keyMap = reader.lines().collect(Collectors.toConcurrentMap(str -> str.split(":")[0],
                            str -> new AtomicInteger(Integer.parseInt(str.split(":")[1]))));
                    logger.info("id列表初始化完毕");
                } else {
                    keyMap = new ConcurrentHashMap<>();
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
    
        public static void shotDown() {
            try {
                File file = new File(System.getProperty("user.dir") + "/snow.txt");
                BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file)));
                keyMap.forEach((key, value) -> {
                    try {
                        writer.write(key + ":" + value.getAndIncrement() + "\r\n");
                    } catch (IOException e) {
                        logger.error("写文件io异常:" + e.getMessage());
                    }
                });
                writer.close();
                logger.info("id持久化完毕");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            Runtime.getRuntime().addShutdownHook(new Thread(SnowIdUtils::shotDown));
            for (int i = 0; i < 4; i++) {
                System.out.println(idKey("userKey"));
            }
        }
    }
    

    拿着用就行了,这个东西比较简单。没啥写的,勿喷

    展开全文
  • java创建id自增的类

    千次阅读 2020-12-07 11:34:23
    private int id; // 学号 private String name; // 姓名 private int age; // 年龄 static String room; // 所在教室 private static int idCounter = 0; // 学号计数器,每当new了一个新对象的时候,计数器++ ...
    
    public class Student {
    
        private int id; // 学号
        private String name; // 姓名
        private int age; // 年龄
        static String room; // 所在教室
        private static int idCounter = 0; // 学号计数器,每当new了一个新对象的时候,计数器++
    
        public Student() {
            this.id = ++idCounter;
        }
    
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
            this.id = ++idCounter;
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    
    
    展开全文
  • id”作为主键的,它可以是任何类型的,默认是个ObjectId对象(在Java中则表现为字符串),那么为什么MongoDB没有采用其他比较常规的做法(比如MySql的自增主键),而是采用了ObjectId的形式来实现?别着急,咱们看看...

    1.了解MongoDB的ObjectId

            MongoDB的文档固定是使用“_id”作为主键的,它可以是任何类型的,默认是个ObjectId对象(在Java中则表现为字符串),那么为什么MongoDB没有采用其他比较常规的做法(比如MySql的自增主键),而是采用了ObjectId的形式来实现?别着急,咱们看看ObjectId的生成方式便可知悉。
            ObjectId使用12字节的存储空间,每个字节两位十六进制数字,是一个24位的字符串。由于看起来很长,不少人会觉得难以处理,其实不然。ObjectId是由客户端生成的,按照如下方式生成:


    • 前4位是一个从标准纪元开始的时间戳,是一个int类别,只不过从十进制转换为了十六进制。这意味着这4个字节隐含了文档的创建时间,将会带来一些有用的属性。并且时间戳处于字符的最前面,同时意味着ObjectId大致会按照插入顺序进行排序,这对于某些方面起到很大作用,如作为索引提高搜索效率等等。使用时间戳还有一个好处是,某些客户端驱动可以通过ObjectId解析出该记录是何时插入的,这也解答了我们平时快速连续创 建多个Objectid时,会发现前几位数字很少发现变化的现实,因为使用的是当前时间,很多用户担心要对服务器进行时间同步,其实这个时间戳的真实值并 不重要,只要其总不停增加就好。
    • 接下来的3个字节,是所在主机的唯一标识符,一般是机器主机名的散列值,这样就确保了不同主机生成不同的机器hash值,确保在分布式中不造成冲突,这也就是在同一台机器生成的objectid中间的字符串都是一模一样的原因。
    • 上面的机器字节是为了确保在不同机器产生的ObjectId不冲突,而PID就是为了在同一台机器不同的mongodb进程产生了ObjectId不冲突。
    • 前面的9个字节是保证了一秒内不同机器不同进程生成ObjectId不冲突,最后的3个字节是一个自动增加的计数器,用来确保在同一秒内产生的ObjectId也不会冲突,允许256的3次方等于16777216条记录的唯一性。
            因此,MongoDB不使用自增主键,而是使用ObjectId。在分布式环境中,多个机器同步一个自增ID不但费时且费力,MongoDB从一开始就是设计用来做分布式数据库的,处理多个节点是一个核心要求,而ObjectId在分片环境中要容易生成的多。

    2.手动实现自增ID

            ObjectId确实是有很大的好处,但有时候由于某些不可抗力的因素或需求,我们仍需要实现一个自增的数值ID,笔者查阅了网上的资料,大多都是一个套路:使用一个单独的集合A来记录每个集合中的ID最大值,然后每次向集合B中插入文档时,去查找集合A中集合B所对应的ID最大值,取出来并+1,然后更新集合A、根据这个ID再插入文档。下面笔者通过网上一种自认为好点的方式来实现,因为笔者用的是Spring Data MongoDB……


    2.1 定义序列实体类SeqInfo

    我们需要用这个集合来存储每个集合的ID记录自增到了多少,如下代码:

    [java]  view plain  copy
    1. package com.jastar.autokey.entity;  
    2.   
    3. import org.springframework.data.annotation.Id;  
    4. import org.springframework.data.mongodb.core.mapping.Document;  
    5. import org.springframework.data.mongodb.core.mapping.Field;  
    6.   
    7. /** 
    8.  * 模拟序列类 
    9.  *  
    10.  * @author Jastar·Wang 
    11.  * @date 2017年5月27日 
    12.  */  
    13. @Document(collection = "sequence")  
    14. public class SeqInfo {  
    15.   
    16.     @Id  
    17.     private String id;// 主键  
    18.   
    19.     @Field  
    20.     private String collName;// 集合名称  
    21.   
    22.     @Field  
    23.     private Long seqId;// 序列值  
    24.   
    25.     // 省略getter、setter  
    26.   
    27. }  

    2.2 定义注解AutoIncKey

    我们需要通过这个注解标识主键ID需要自动增长,如下代码:

    [java]  view plain  copy
    1. package com.jastar.autokey.annotation;  
    2.   
    3. import java.lang.annotation.ElementType;  
    4. import java.lang.annotation.Retention;  
    5. import java.lang.annotation.RetentionPolicy;  
    6. import java.lang.annotation.Target;  
    7.   
    8. /** 
    9.  * 自定义注解,标识主键字段需要自动增长 
    10.  * <p> 
    11.  * ClassName: AutoIncKey 
    12.  * </p> 
    13.  * <p> 
    14.  * Copyright: (c)2017 Jastar·Wang,All rights reserved. 
    15.  * </p> 
    16.  *  
    17.  * @author jastar-wang 
    18.  * @date 2017年5月27日 
    19.  */  
    20. @Target(ElementType.FIELD)  
    21. @Retention(RetentionPolicy.RUNTIME)  
    22. public @interface AutoIncKey {  
    23.       
    24. }  

    2.3 定义业务实体类Student

    [java]  view plain  copy
    1. package com.jastar.autokey.entity;  
    2.   
    3. import org.springframework.data.annotation.Id;  
    4. import org.springframework.data.mongodb.core.mapping.Document;  
    5. import org.springframework.data.mongodb.core.mapping.Field;  
    6.   
    7. import com.jastar.autokey.annotation.AutoIncKey;  
    8.   
    9. @Document(collection = "student")  
    10. public class Student {  
    11.   
    12.     @AutoIncKey  
    13.     @Id  
    14.     private Long id = 0L;// 为什么赋了默认值?文章后说明  
    15.   
    16.     @Field  
    17.     private String name;  
    18.   
    19.     // 省略getter、setter  
    20. }  

    2.4 定义监听类SaveEventListener

    →2017年7月26日更新:

            注意下面代码中重写的onBeforeConvert方法在1.8版本开始就废弃了,不过官方推荐: Please use onBeforeConvert(BeforeConvertEvent),各位猿友可以研究下这个方法如何使用,我想 BeforeConvertEvent 对象里面应该会有所需要的参数信息,在此我就不再亲测了。


    因为使用的是Spring Data MongoDB,所以可以重写监听事件里面的方法,而进行某些处理,该类需要继承AbstractMongoEventListener类,并且需交由Spring管理,如下代码:

    [java]  view plain  copy
    1. package com.jastar.autokey.listener;  
    2.   
    3. import java.lang.reflect.Field;  
    4.   
    5. import org.springframework.beans.factory.annotation.Autowired;  
    6. import org.springframework.data.mongodb.core.FindAndModifyOptions;  
    7. import org.springframework.data.mongodb.core.MongoTemplate;  
    8. import org.springframework.data.mongodb.core.mapping.event.AbstractMongoEventListener;  
    9. import org.springframework.data.mongodb.core.query.Criteria;  
    10. import org.springframework.data.mongodb.core.query.Query;  
    11. import org.springframework.data.mongodb.core.query.Update;  
    12. import org.springframework.stereotype.Component;  
    13. import org.springframework.util.ReflectionUtils;  
    14.   
    15. import com.jastar.autokey.annotation.AutoIncKey;  
    16. import com.jastar.autokey.entity.SeqInfo;  
    17.   
    18. /** 
    19.  * 保存文档监听类<br> 
    20.  * 在保存对象时,通过反射方式为其生成ID 
    21.  * <p> 
    22.  * ClassName: SaveEventListener 
    23.  * </p> 
    24.  * <p> 
    25.  * Copyright: (c)2017 Jastar·Wang,All rights reserved. 
    26.  * </p> 
    27.  *  
    28.  * @author jastar-wang 
    29.  * @date 2017年5月27日 
    30.  */  
    31. @Component  
    32. public class SaveEventListener extends AbstractMongoEventListener<Object> {  
    33.   
    34.     @Autowired  
    35.     private MongoTemplate mongo;  
    36.   
    37.     @Override  
    38.     public void onBeforeConvert(final Object source) {  
    39.         if (source != null) {  
    40.             ReflectionUtils.doWithFields(source.getClass(), new ReflectionUtils.FieldCallback() {  
    41.                 public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {  
    42.                     ReflectionUtils.makeAccessible(field);  
    43.                     // 如果字段添加了我们自定义的AutoIncKey注解  
    44.                     if (field.isAnnotationPresent(AutoIncKey.class)) {  
    45.                         // 设置自增ID  
    46.                         field.set(source, getNextId(source.getClass().getSimpleName()));  
    47.                     }  
    48.                 }  
    49.             });  
    50.         }  
    51.     }  
    52.   
    53.     /** 
    54.      * 获取下一个自增ID 
    55.      *  
    56.      * @param collName 
    57.      *            集合(这里用类名,就唯一性来说最好还是存放长类名)名称 
    58.      * @return 序列值 
    59.      */  
    60.     private Long getNextId(String collName) {  
    61.         Query query = new Query(Criteria.where("collName").is(collName));  
    62.         Update update = new Update();  
    63.         update.inc("seqId"1);  
    64.         FindAndModifyOptions options = new FindAndModifyOptions();  
    65.         options.upsert(true);  
    66.         options.returnNew(true);  
    67.         SeqInfo seq = mongo.findAndModify(query, update, options, SeqInfo.class);  
    68.         return seq.getSeqId();  
    69.     }  
    70. }  

    2.5 单元测试

    [java]  view plain  copy
    1. @Test  
    2. public void save() {  
    3.     Student stu = new Student();  
    4.     stu.setName("张三");  
    5.     service.save(stu);  
    6.     // service.update(stu);  
    7.     System.out.println("已生成ID:" + stu.getId());  
    8. }  

    2.6 总结

    经过测试,以上流程没有问题,会得到期望的结果,但是有以下几点需要注意:

    (1)为什么我在Student类中为主键赋了一个默认值0L?

    答:我在此自增方式原作者文章中发现这么一句,“注意自增ID的类型不要定义成Long这种包装类,mongotemplate的源码里面对主键ID的类型有限制”。测试后发现,如果ID定义为原生类型确实是没有问题的。当ID定义为包装类的情况下,如果在onBeforeConvert方法之前没有给ID设置值,是会报错的,我猜测可能是因为内部转换类型时如果ID是空值而无法转换引起的,因此,我赋了一个默认值,这样就不会报错了,包装类也可以使用(不过这样好像跟原生类型就没什么区别了,没什么意义)。

    (2)这个监听器会不会影响修改操作?

    答:测试发现,不会影响,水平有限,本人也不知作何解释,不要打我……

    (3)这种方式会有并发问题吗?

    答:不会的!根据官方文档说明,findAndModify一个原子性操作,不过有这么一句“When the findAndModify command includes the upsert: true option and the query field(s) is not uniquely indexed, the command could insert a document multiple times in certain circumstances.”,大概意思是说当查询和更新两个操作都存在时,如果查询的字段没有唯一索引的话,该命令可能会在某些情况下更新/插入 文档多次,参考链接:戳我戳我以上演示的是只存储了集合所对应的实体类的短名称,短名称是会重复的,所以这种方法不妥,还是记录长名称吧。

    展开全文
  • MongoDB进阶(九)Java实现MongoDB自增主键ID

    万次阅读 热门讨论 2017-05-27 18:41:01
    id”作为主键的,它可以是任何类型的,默认是个ObjectId对象(在Java中则表现为字符串),那么为什么MongoDB没有采用其他比较常规的做法(比如MySql的自增主键),而是采用了ObjectId的形式来实现?别着急,咱们看看...
  • ORACLE 实现 ID 自增

    2021-07-22 10:05:07
    前言 目录 前言 具体命令 具体详解: ...所以通过创建序列(sequence)的方式来实现oracle id自增 具体命令 create sequence TRAIN_USER INCREMENT BY 1 MINVALUE 1 MAXVALUE 9999999999..
  • 主要介绍了Java实现Twitter的分布式自增ID算法snowflake,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 参考链接:mybatis插入数据时,自动获取主键的自增id
  • 这些ID是使用java代码实现的并不是通过数据库的自增实现的.下面是我写的一个简单的ID工具类,在使用的过程中你需要将最后一次的编号保存下来,你可以建一张表来维护这个自增的ID 这个自增的ID生成是线程安全的,而且在...
  • SpringBoot+mongoDB实现id自增

    千次阅读 2019-02-08 15:51:00
    这段时间给朋友做了一个微信小程序,顺便练习一下spring boot,虽然项目使用的是JPA+MySQL,但是好奇尝试了一下MongoDB实现自增ID,虽然MongoDB很少有自增ID的需求(在分布式环境中,多个机器同步一个自增ID不但费时...
  • //useGeneratedKeys="false" 必须否则会报sql命令未正确结束 INSERT INTO SCM_ASSESS_TEMPLATE_CATEGORY(TEMPLATE_CATEGORY_ID,TEMPLATE_ID, CATEGORY_ID, CATEGORY_TYPE, CATEGORY_NAME,...
  • Java实现数据新增获取自增ID

    万次阅读 2019-07-07 08:26:57
    Java实现数据新增获取自增ID 有时候因为新增的需求需要获取刚刚新增的数据的自增的主键ID,可以使用使用 PreparedStatement.RETURN_GENERATED_KEYS(关键看你使用哪个接口与数据库交互,都有RETURN_GENERATED_KEYS...
  • 想要向mysql数据库中插入一条记录,因为设计的表时自动递增的,那么如果插入多条记录,每次都要设置主键的话工作量会很大,而且难免会有重复的主键,这时候就要使用强大的主键自增的功能了。 在没有使用主键自增...
  • ID自增JAVA类方法

    2013-12-20 17:06:52
    ID自增java类方法,不用数据库主键自增的可以考虑试试这个,自己定义方式
  • 向Oracle插入数据实现Id自增

    千次阅读 2016-08-20 17:09:40
     id char(5) primary key not null,  name char(10) ); (1)建立sequence create sequence test_id increment by 1 start with 1; (2)建立触发器 A)执行命令ed test打开窗口,填写以下内容 cr
  • 主要介绍了java获取新insert数据自增id实现方法,在具体生成id的时候,我们的操作顺序一般是:先在主表中插入记录,然后获得自动生成的id,以它为基础插入从表的记录,需要的朋友可以参考下
  • 比如我有两张表,role_auth(角色菜单表)和role(角色表),表结构如下: ... `role_id` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '角色id', `menu_id...
  • mongodb java自增 id实现

    千次阅读 2015-04-06 09:19:23
    mongodb没有关于自增id实现 1。一般思路是取出最大的id ,然后+1。 除非取最大的id和+1这两个步骤是原子的,否则一定存在并发问题(有可能两个线程同时取到一个id),显然这样不可取。 2。另外,也可以将插入和...
  • 【shrimpcolo ...】 背景 Mongodb本身是没有类似mysql那种_id自增功能的,Mongodb使用ObjectId作为自己的_id, Java中表现的是字符串。 ObjectId 示例 5a785ed5 07267d 4168 ac8957 其中: 1. 5a7...
  • java实现MongoDB主键自增

    千次阅读 2018-06-07 17:33:02
    java实现MongoDB主键自增 1.定义序列实体类SeqInfo: 存储每个集合的ID记录 //@Document 把一个java类声明为mongodb的文档,可以通过collection参数指定这个类对应的文档 @Document(collection = &quot;...
  • hibernate实现ID序列自增

    千次阅读 2018-12-21 18:46:51
    实体类里的id 配合数据库的序列 , 实现id自增 第一步: 数据库里边要新建一个序列,最好以相关表中的id命名. 程序中的实体类例代码如下: @Entity @Table(name = "XXGX_RBBTJ") public class ...
  • JDBC获取自增主键
  • xml中的sql头部写法: <insert id="insert" useGeneratedKeys="true" keyProperty="id" keyColumn="id"> java中写法 xx.insert(entity) 自增id=entity.getid() ...这里的entity插入后本身id会被写入自增id

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 59,812
精华内容 23,924
关键字:

java实现id自增

java 订阅