精华内容
下载资源
问答
  • java怎样将数据保存到缓存中,之后再保存
    千次阅读
    2021-02-12 19:55:49

    展开全部

    Java中可以使用队列来保存62616964757a686964616fe59b9ee7ad9431333337613163数据,当使用的时候,加上锁,防止其他进程访问,当不用的时候保存到数据库里面,示例如下:package com.henry;

    import java.util.HashMap;

    import java.util.Map;

    import java.util.Random;

    import java.util.concurrent.locks.ReadWriteLock;

    import java.util.concurrent.locks.ReentrantReadWriteLock;

    public class CacheDataTest {

    static Map dataMap=new HashMap();

    static ReadWriteLock lock=new ReentrantReadWriteLock();//创建读写锁的实例

    static Object getData(Integer key){

    lock.readLock().lock();//读取前先上锁

    Object val=null;

    try{

    val=dataMap.get(key);

    if(val == null){

    // Must release read lock before acquiring write lock

    lock.readLock().unlock();

    lock.writeLock().lock();

    try{

    //可能已经由其他线程写入数据

    if(val==null){

    //dataMap.put(key, "");//query from db

    val=queryDataFromDB(key);

    }

    }finally{

    //Downgrade by acquiring read lock before releasing write lock

    lock.readLock().lock();

    // Unlock write, still hold read

    lock.writeLock().unlock();

    }

    }

    }finally{

    lock.readLock().unlock();//最后一定不要忘记释放锁

    }

    System.out.println("get data key="+key+">val="+val);

    return val;

    }

    static Object queryDataFromDB(Integer key){

    Object val=new Random().nextInt(1000);

    dataMap.put(key, val);

    System.out.println("write into data key="+key+">val="+val);

    return val;

    }

    public static void main(String[] args) {

    for(int i=0;i<10;i++){

    new Thread(new Runnable(){public void run() {

    getData(new Random().nextInt(5));

    }}).start();

    }

    }

    }

    更多相关内容
  • 零基础学会REDIS缓存数据库在JAVA中的使用。从REDIS的安装和使用开始,到Java程序与REDIS数据库进行连接互动,简单明了。
  • 本篇文章主要介绍了Java自定义注解实现Redis自动缓存的方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下。
  • Windows 写入缓存

    2021-01-10 21:37:19
    本文讨论 Windows 写入缓存设置,该设置会使系统在断电或操作系统崩溃的情况下容易发生数据丢失或损坏。 该设置在某些 Windows 配置中默认开启。 为磁盘启用 Windows 写入缓存意味着 Caché(或任何程序)写入该磁盘的...

    本文讨论 Windows 写入缓存设置,该设置会使系统在断电或操作系统崩溃的情况下容易发生数据丢失或损坏。 该设置在某些 Windows 配置中默认开启。

    为磁盘启用 Windows 写入缓存意味着 Caché(或任何程序)写入该磁盘的某些内容不一定会立即提交到持久性存储(即使 Caché 在其写入阶段的特定关键点刷新从操作系统缓存到磁盘的写入也是如此)。 如果计算机断电,为该设备缓存的任何内容都会丢失,除非该设备的缓存是非易失性的或者由电池供电。 Caché 依靠操作系统来保证数据的持久性。 在这种情况下,保证是无效的。 对于 Caché 来说,这可能会导致数据库损坏或者数据库或日志文件中的数据缺失。

    InterSystems 的文档显示,使“写入映像日志”提供的保证失效的一种情况是回写缓存内容丢失(请参见 http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GCDI_wij#GCDI/wij_limits)。 InterSystems 全球响应中心的数据完整性团队研究了许多 Windows 平台上的数据丢失或损坏案例,这些案例中有证据表明,回写缓存内容丢失是由该设置的值导致的。

    值得一提的是,磁盘的缓存可能会有效防止发生此类问题。 如果相关磁盘的缓存是非易失性的或由电池供电,则即使开启该设置,写入磁盘也应该是安全的。 如果相关存储比直接连接的磁盘更复杂,您需要了解在该存储基础架构的何处对写入进行缓存,以及这些缓存是否是易失性的或者是否由电池供电,以评估风险。

    您可以转到“设备管理器”,展开“磁盘驱动器”部分,然后查看给定磁盘的属性来查看设置。 我们感兴趣的设置在“策略”选项卡上。

    界面上的用词并不总是与您在这里看到的相同,可能因设备类型的不同而有所不同。 不过,这是常见的用词表述,并且 Windows 明确指出,开启该设置后,如果机器断电或崩溃,系统可能会发生数据丢失。

    接下来是同一机器上另一个磁盘的示例,其中的影响没有那么明显。在这里选择“更好的性能”将与在另一个示例中选择“启用写入缓存”带来相同问题。

    在这两个示例中,您看到的选定设置都是该设备的默认设置,我没有更改过。 您可以看到,在第一个示例中,默认设置使设备处于风险之中,而第二个示例则没有。 据我所知,并没有通用于所有设备类型或 Windows 版本的默认设置。 换句话说,需要在每台设备上检查此设置,以了解设备是否存在此风险。

    作为系统管理员,处理这种情况有三种基本方法。 禁用该设置是最简单的方法,可确保不会面临此风险。 但是,禁用该设置可能会对性能产生不可接受的影响。 如果是这种情况,您可能更愿意开启该设置,并将计算机连接到不间断电源。 这样做可以防止断电导致的数据丢失或损坏,因为 UPS 应该可以在断电时提供足够的时间让您从容地关机。 最后一个选择是简单地接受服务器断电或崩溃时数据丢失的风险。 InterSystems 建议不要采用此方式。 消费级 UPS 已相当便宜,而且检测完整性问题并从中恢复可能非常耗时又会产生问题。

    InterSystems 建议您在未确保计算机连接到不间断电源的情况下不要开启此设置。 如果存储是外部设备,则该设备也需要连接到 UPS。

    展开全文
  • 缓存List并写入文件持久化.zip
  • 为您提供Ehcache Java缓存框架下载,EhCache 是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider。主要的特性有:1. 快速.2. 简单.3. 多种缓存策略4. 缓存数据有两级:内存和...
  • Java+MySQL+redis缓存

    热门讨论 2016-12-18 14:17:34
    案例中数据来自MySQL数据库,对查询出来的数据缓存到redis,redis缓存工具可以将缓存string,bean,list,map等类型,代码中有详细的注释,而且还将要缓存的数据进行了序列化,大家可以借鉴,进而更改成自己想要的格式...
  • 在工作总常常需要用到缓存,而redis往往是首选,但是短期的数据缓存一般我们还是会用到本地缓存。本文提供一个我在工作中用到的缓存工具,该工具代码为了演示做了一些调整。如果拿去使用的话,可以考虑做成注入Bean...

    目录

    前言

    环境依赖

    代码

    总结


    前言

    在工作总常常需要用到缓存,而redis往往是首选,但是短期的数据缓存一般我们还是会用到本地缓存。本文提供一个我在工作中用到的缓存工具,该工具代码为了演示做了一些调整。如果拿去使用的话,可以考虑做成注入Bean对象,看具体需求了。

    环境依赖

    先添加maven依赖

    .

            <dependency>
                <groupId>com.google.guava</groupId>
                <artifactId>guava</artifactId>
                <version>30.1.1-jre</version>
            </dependency>
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>5.5.2</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>

    代码

    不废话,上代码了。

    package ai.guiji.csdn.tools;
    
    import cn.hutool.core.thread.ThreadUtil;
    import com.google.common.cache.*;
    import lombok.extern.slf4j.Slf4j;
    
    import java.text.MessageFormat;
    import java.util.Map;
    import java.util.concurrent.TimeUnit;
    import java.util.function.Consumer;
    import java.util.function.Function;
    import java.util.stream.LongStream;
    
    /** @Author 剑客阿良_ALiang @Date 2021/12/30 17:57 @Description: 缓存工具 */
    @Slf4j
    public class CacheUtils {
    
      private static LoadingCache<Long, String> cache;
    
      /**
       * 初始化缓存方法
       *
       * @param totleCount 缓存池上限
       * @param overtime 超时时间
       * @param unit 时间单位
       * @param handleNotExist 处理不存在key方法
       * @param handleRemove 移除主键消费
       */
      private static void initCache(
          Integer totleCount,
          Integer overtime,
          TimeUnit unit,
          Function<Long, String> handleNotExist,
          Consumer<Long> handleRemove) {
        cache =
            CacheBuilder.newBuilder()
                // 缓存池大小
                .maximumSize(totleCount)
                // 设置时间对象没有被读/写访问则对象从内存中删除
                .expireAfterWrite(overtime, unit)
                // 移除监听器
                .removalListener(
                    new RemovalListener<Long, String>() {
                      @Override
                      public void onRemoval(RemovalNotification<Long, String> rn) {
                        handleRemove.accept(rn.getKey());
                      }
                    })
                .recordStats()
                .build(
                    new CacheLoader<Long, String>() {
                      @Override
                      public String load(Long aLong) throws Exception {
                        return handleNotExist.apply(aLong);
                      }
                    });
        log.info("初始化缓存");
      }
    
      /**
       * 存入缓存
       *
       * @param key 键
       * @param value 值
       */
      public static void put(Long key, String value) {
        try {
          log.info("缓存存入:[{}]-[{}]", key, value);
          cache.put(key, value);
        } catch (Exception exception) {
          log.error("存入缓存异常", exception);
        }
      }
    
      /**
       * 批量存入缓存
       *
       * @param map 映射
       */
      public static void putMap(Map<Long, String> map) {
        try {
          log.info("批量缓存存入:[{}]", map);
          cache.putAll(map);
        } catch (Exception exception) {
          log.error("批量存入缓存异常", exception);
        }
      }
    
      /**
       * 获取缓存
       *
       * @param key 键
       */
      public static String get(Long key) {
        try {
          return cache.get(key);
        } catch (Exception exception) {
          log.error("获取缓存异常", exception);
          return null;
        }
      }
    
      /**
       * 删除缓存
       *
       * @param key 键
       */
      public static void removeKey(Long key) {
        try {
          cache.invalidate(key);
        } catch (Exception exception) {
          log.error("删除缓存异常", exception);
        }
      }
    
      /**
       * 批量删除缓存
       *
       * @param keys 键
       */
      public static void removeAll(Iterable<Long> keys) {
        try {
          cache.invalidateAll(keys);
        } catch (Exception exception) {
          log.error("批量删除缓存异常", exception);
        }
      }
    
      /** 清理缓存 */
      public static void clear() {
        try {
          cache.invalidateAll();
        } catch (Exception exception) {
          log.error("清理缓存异常", exception);
        }
      }
    
      /**
       * 获取缓存大小
       *
       * @return 长度
       */
      public static long size() {
        return cache.size();
      }
    
      public static void main(String[] args) {
        initCache(
            Integer.MAX_VALUE,
            10,
            TimeUnit.SECONDS,
            k -> {
              log.info("缓存:[{}],不存在", k);
              return "";
            },
            x -> log.info("缓存:[{}],已经移除", x));
        System.out.println(size());
        LongStream.range(0, 10).forEach(a -> put(a, MessageFormat.format("tt-{0}", a)));
        System.out.println(cache.asMap());
        ThreadUtil.sleep(5000);
        LongStream.range(0, 10)
            .forEach(
                a -> {
                  System.out.println(get(a));
                  ThreadUtil.sleep(1000);
                });
        System.out.println(cache.asMap());
        ThreadUtil.sleep(10000);
        System.out.println(cache.asMap());
      }
    }
    

    代码说明

    1、在初始化loadingCache的时候,可以添加缓存的最大数量、消逝时间、消逝或者移除监听事件、不存在键处理等等。在上面的代码中,我初始化缓存大小为Integer的最大值,写入10秒后消逝,如不存在key返回空字符串等等。

    2、该类也提供了put、putAll、get、remove、removeAll、clear、size方法,可以对缓存进行存、取、删、清理、大小等操作。

    3、main演示方法中,先往缓存存入10个数据,然后过5秒后每秒取一个数据,并且打印一下缓存中的全部内容。

    4、补充一句LoadingCache是线程安全的哦。

    演示一下

    15:31:53.495 [main] INFO ai.guiji.csdn.tools.CacheUtils - 初始化缓存
    0
    15:31:53.502 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[0]-[tt-0]
    15:31:53.508 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[1]-[tt-1]
    15:31:53.508 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[2]-[tt-2]
    15:31:53.508 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[3]-[tt-3]
    15:31:53.508 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[4]-[tt-4]
    15:31:53.508 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[5]-[tt-5]
    15:31:53.508 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[6]-[tt-6]
    15:31:53.508 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[7]-[tt-7]
    15:31:53.509 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[8]-[tt-8]
    15:31:53.509 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[9]-[tt-9]
    {6=tt-6, 5=tt-5, 0=tt-0, 8=tt-8, 7=tt-7, 2=tt-2, 1=tt-1, 9=tt-9, 3=tt-3, 4=tt-4}
    tt-0
    tt-1
    tt-2
    tt-3
    tt-4
    15:32:03.572 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[5],已经移除
    15:32:03.573 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[6],已经移除
    15:32:03.573 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[5],不存在

    15:32:04.581 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[6],不存在

    15:32:05.589 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[0],已经移除
    15:32:05.589 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[7],已经移除
    15:32:05.589 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[8],已经移除
    15:32:05.589 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[7],不存在

    15:32:06.589 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[8],不存在

    15:32:07.591 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[1],已经移除
    15:32:07.591 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[2],已经移除
    15:32:07.591 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[9],已经移除
    15:32:07.591 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[9],不存在

    {6=, 5=, 8=, 7=, 9=}
    {}

    Process finished with exit code 0
     

    可以看到,后面的5-9在内存中已经不存在对应的值了。

    总结

    本文提供的工具代码主要是为了演示,实际工作中可以按照自己的需求做调整。

     还有补充一下,最近博主在参加评选博客之星活动。如果你喜欢我的文章的话,不妨给我点个五星,投投票吧,谢谢大家的支持!!链接地址:https://bbs.csdn.net/topics/603956455

    分享:

            在梦中,我以为人生很漫长,会远得连尽头也看不见,没想到我匆匆翻看,人生,却再也无法逆转。在当下,我以为时间很重,会重得连时针都走不动。 没想到我轻轻一吹,时间,却再也没回来过。——《言叶之庭》

    如果本文对你有帮助的话,点个赞吧,谢谢!!

    展开全文
  • SimpleCache 是一个简单易用的java缓存工具,用来简化缓存代码的编写,让你摆脱单调乏味的重复工作! 1. 完全透明的缓存支持,对业务代码零侵入 2. 支持使用Redis和Memcached作为后端缓存。 3. 支持缓存数据分区规则...
  • Java文件写入的6种方法

    千次阅读 2021-10-29 00:21:20
    写程序时经常会碰到读写文件的场景,在Java中操作文件的方法本质上只有两种:字符流和字节流,而他们的实现类又有很多,因此,有时候用起来,就会比较乱。这篇文章系统介绍了Java操作文件的几种...

    写程序时经常会碰到读写文件的场景,在Java中操作文件的方法本质上只有两种:字符流和字节流,而他们的实现类又有很多,因此,有时候用起来,就会比较乱。

    这篇文章系统介绍了Java操作文件的几种方式,学习一下,

    https://www.cnblogs.com/rinack/p/14173936.html

    1baa57d2c74472a3f60337ad10a34721.png

    b807b7acd1c1f7f5c9b2b70558e48b59.png

    e74c47e3b968c063c98cd3ca619b6e89.png        

    1cfed231c156d981a8466e812423ddb0.png

    ef665f569817a71e515025db4cae7685.png

    37dc15cd877a390015159aa2455eb3bc.png

    918245815ea25e29576bb6467841862c.png

    679bb82138dc7a3a41f934bdca276a34.png

    a77557c1beb6755b458c7a7499df5f5f.png

    e6f0ef87fa7dce5c195649c7ec18e2a2.png

    FileWriter类的实现如下,

    /** 
      * 方法 1:使用 FileWriter 写文件 
      * @param filepath 文件目录 
      * @param content  待写入内容 
      * @throws IOException 
      */ 
    public static void fileWriterMethod(String filepath, String content) throws IOException { 
        try (FileWriter fileWriter = new FileWriter(filepath)) { 
            fileWriter.append(content); 
        } 
    }

    只需要传入具体的文件路径和待写入的内容即可,调用代码如下,

    public static void main(String[] args) { 
        fileWriterMethod("/Users/mac/Downloads/io_test/write1.txt", "Hello, Java."); 
    }

    130d3da7d6c50656ee7ab99ff15010ba.png

    了解了缓存区的优点之后,咱们回到本文的主题,接下来我们用BufferedWriter来文件的写入,实现代码如下,

    /** 
     * 方法 2:使用 BufferedWriter 写文件 
     * @param filepath 文件目录 
     * @param content  待写入内容 
     * @throws IOException 
     */ 
    public static void bufferedWriterMethod(String filepath, String content) throws IOException { 
        try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filepath))) { 
            bufferedWriter.write(content); 
        } 
    }

    797a9fffb0a381c64617ac7449ab9236.png

    /** 
     * 方法 3:使用 PrintWriter 写文件 
     * @param filepath 文件目录 
     * @param content  待写入内容 
     * @throws IOException 
     */ 
    public static void printWriterMethod(String filepath, String content) throws IOException { 
        try (PrintWriter printWriter = new PrintWriter(new FileWriter(filepath))) { 
            printWriter.print(content); 
        } 
    }

    1f53581858068143eff1dd71eeb414da.png

    /** 
     * 方法 4:使用 FileOutputStream 写文件 
     * @param filepath 文件目录 
     * @param content  待写入内容 
     * @throws IOException 
     */ 
    public static void fileOutputStreamMethod(String filepath, String content) throws IOException { 
        try (FileOutputStream fileOutputStream = new FileOutputStream(filepath)) { 
            byte[] bytes = content.getBytes(); 
            fileOutputStream.write(bytes); 
        } 
    }

    94d3061ecab1f94e1d7c2a5768580113.png

    /** 
     * 方法 5:使用 BufferedOutputStream 写文件 
     * @param filepath 文件目录 
     * @param content  待写入内容 
     * @throws IOException 
     */ 
    public static void bufferedOutputStreamMethod(String filepath, String content) throws IOException { 
        try (BufferedOutputStream bufferedOutputStream = new BufferedOutputStream( 
                new FileOutputStream(filepath))) { 
            bufferedOutputStream.write(content.getBytes()); 
        } 
    }

    4673ca0210ea87fe6490e8639b493e9d.png

    /** 
     * 方法 6:使用 Files 写文件 
     * @param filepath 文件目录 
     * @param content  待写入内容 
     * @throws IOException 
     */ 
    public static void filesTest(String filepath, String content) throws IOException { 
        Files.write(Paths.get(filepath), content.getBytes()); 
    }

    5aed868fc1a0fe02a8a098c139a50ff0.png

    import java.io.*; 
    import java.nio.file.Files; 
    import java.nio.file.Paths; 
     
    public class WriteExample { 
        public static void main(String[] args) throws IOException { 
            // 构建写入内容 
            StringBuilder stringBuilder = new StringBuilder(); 
            for (int i = 0; i < 1000000; i++) { 
                stringBuilder.append("ABCDEFGHIGKLMNOPQRSEUVWXYZ"); 
            } 
            // 写入内容 
            final String content = stringBuilder.toString(); 
            // 存放文件的目录 
            final String filepath1 = "/Users/mac/Downloads/io_test/write1.txt"; 
            final String filepath2 = "/Users/mac/Downloads/io_test/write2.txt"; 
            final String filepath3 = "/Users/mac/Downloads/io_test/write3.txt"; 
            final String filepath4 = "/Users/mac/Downloads/io_test/write4.txt"; 
            final String filepath5 = "/Users/mac/Downloads/io_test/write5.txt"; 
            final String filepath6 = "/Users/mac/Downloads/io_test/write6.txt"; 
     
            // 方法一:使用 FileWriter 写文件 
            long stime1 = System.currentTimeMillis(); 
            fileWriterTest(filepath1, content); 
            long etime1 = System.currentTimeMillis(); 
            System.out.println("FileWriter 写入用时:" + (etime1 - stime1)); 
     
            // 方法二:使用 BufferedWriter 写文件 
            long stime2 = System.currentTimeMillis(); 
            bufferedWriterTest(filepath2, content); 
            long etime2 = System.currentTimeMillis(); 
            System.out.println("BufferedWriter 写入用时:" + (etime2 - stime2)); 
     
            // 方法三:使用 PrintWriter 写文件 
            long stime3 = System.currentTimeMillis(); 
            printWriterTest(filepath3, content); 
            long etime3 = System.currentTimeMillis(); 
            System.out.println("PrintWriterTest 写入用时:" + (etime3 - stime3)); 
     
            // 方法四:使用 FileOutputStream  写文件 
            long stime4 = System.currentTimeMillis(); 
            fileOutputStreamTest(filepath4, content); 
            long etime4 = System.currentTimeMillis(); 
            System.out.println("FileOutputStream 写入用时:" + (etime4 - stime4)); 
     
            // 方法五:使用 BufferedOutputStream 写文件 
            long stime5 = System.currentTimeMillis(); 
            bufferedOutputStreamTest(filepath5, content); 
            long etime5 = System.currentTimeMillis(); 
            System.out.println("BufferedOutputStream 写入用时:" + (etime5 - stime5)); 
     
            // 方法六:使用 Files 写文件 
            long stime6 = System.currentTimeMillis(); 
            filesTest(filepath6, content); 
            long etime6 = System.currentTimeMillis(); 
            System.out.println("Files 写入用时:" + (etime6 - stime6)); 
    
    
        } 
     
        /** 
         * 方法六:使用 Files 写文件 
         * @param filepath 文件目录 
         * @param content  待写入内容 
         * @throws IOException 
         */ 
        private static void filesTest(String filepath, String content) throws IOException { 
            Files.write(Paths.get(filepath), content.getBytes()); 
        } 
     
        /** 
         * 方法五:使用 BufferedOutputStream 写文件 
         * @param filepath 文件目录 
         * @param content  待写入内容 
         * @throws IOException 
         */ 
        private static void bufferedOutputStreamTest(String filepath, String content) throws IOException { 
            try (BufferedOutputStream bufferedOutputStream = new BufferedOutputStream( 
                    new FileOutputStream(filepath))) { 
                bufferedOutputStream.write(content.getBytes()); 
            } 
        } 
     
        /** 
         * 方法四:使用 FileOutputStream  写文件 
         * @param filepath 文件目录 
         * @param content  待写入内容 
         * @throws IOException 
         */ 
        private static void fileOutputStreamTest(String filepath, String content) throws IOException { 
            try (FileOutputStream fileOutputStream = new FileOutputStream(filepath)) { 
                byte[] bytes = content.getBytes(); 
                fileOutputStream.write(bytes); 
            } 
        } 
     
        /** 
         * 方法三:使用 PrintWriter 写文件 
         * @param filepath 文件目录 
         * @param content  待写入内容 
         * @throws IOException 
         */ 
        private static void printWriterTest(String filepath, String content) throws IOException { 
            try (PrintWriter printWriter = new PrintWriter(new FileWriter(filepath))) { 
                printWriter.print(content); 
            } 
        } 
     
        /** 
         * 方法二:使用 BufferedWriter 写文件 
         * @param filepath 文件目录 
         * @param content  待写入内容 
         * @throws IOException 
         */ 
        private static void bufferedWriterTest(String filepath, String content) throws IOException { 
            try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filepath))) { 
                bufferedWriter.write(content); 
            } 
        } 
     
        /** 
         * 方法一:使用 FileWriter 写文件 
         * @param filepath 文件目录 
         * @param content  待写入内容 
         * @throws IOException 
         */ 
        private static void fileWriterTest(String filepath, String content) throws IOException { 
            try (FileWriter fileWriter = new FileWriter(filepath)) { 
                fileWriter.append(content); 
            } 
        } 
    }

    在查看结果之前,我们先去对应的文件夹看看写入的文件是否正常,如下图所示,

    0515e9e661b62be65c7c59be08266a26.png

    从上述结果可以看出,每种方法都正常写入了26 MB的数据,他们最终执行的结果如下图所示,

    e5e52fee47a813c41934dd1b426ef784.png

    4c29b9e9cb7bfca2a258fc47772830d5.png

    7f90c2fd7d9c404880691587df008302.png

    80648265fbe253ffa79c4ec5feb39c17.png

    c70e7074f142a2ba2fa7b79134533630.png


    cc8d9b4ed0e99a3118db8982d0fa53fe.png

    近期更新的文章:

    第七届DAMS中国数据智能管理峰会(上海站) - 文末俩惊喜

    MyBatis动态传递参数的两种方式#{}和${}

    OpenJDK的一个bug

    DTCC参会归来有感

    小白学习MySQL - 聊聊数据备份的重要性

    文章分类和索引:

    《公众号800篇文章分类和索引

    展开全文
  • 为您提供EhcacheJava缓存框架下载,EhCache 是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider。主要的特性有:1. 快速.2. 简单.3. 多种缓存策略4. 缓存数据有两级:内存和...
  • java中的缓存技术该如何实现

    千次阅读 2021-02-13 01:49:23
    1缓存为什么要存在?2缓存可以存在于什么地方?3缓存有哪些属性?4缓存介质?搞清楚这4个问题,那么我们就可以随意的通过应用的场景来判断使用何种缓存了.1. 缓存为什么要存在?一 般情况下,一个网站,或者一个应用,它的...
  • 读取文件的时候如果是用的read方法(字节流),...可以通过BufferedReader 流的形式进行流缓存,之后通过readLine方法获取到缓存的内容。BufferedReader bre = null;try {String file = "D:/test/test.txt";bre = ne...
  • java本地缓存 google guava

    千次阅读 2020-05-29 08:36:22
    本地缓存产生背景: 本地缓存是指在我们本地的物理空间开辟出一片物理空间,专门用来存储...java的本地缓存存储在jvm的堆区的老年 代里,大小大约有几百兆。 本地缓存应用场景: 本地缓存虽然可以在本地缓存一些频繁
  • } } 我没有redis 只能模拟一个 你看下 其实 你就多了一步 从缓存中取值 判断不能 等于 30000毫秒 因为 时间会有所偏差 可能大于 所以 大于等于,你要是觉得 毫秒太长你可以 转换成秒存入 在计算 第二种 的话 你的...
  • 主要介绍了java异步写日志到文件中实现代码的相关资料,需要的朋友可以参考下
  • 缓存详解-在java项目中使用缓存

    千次阅读 2021-03-22 15:13:38
    一、概述在java项目中经常有使用缓存的场景,这时候如何使用缓存就很重要了,本篇文章言简意赅,带你读透缓存二、java常用的缓存java项目中经常使用到的缓存主要分为两个种类1、内存类java中的Map、List等容器实现...
  • EhCache 是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider。 主要的特性有: 1. 快速. 2. 简单. 3. 多种缓存策略 4. 缓存数据有两级:内存和磁盘,因此无需担心容量问题 5. ...
  • Java文件写入的六种方式

    千次阅读 2021-05-23 16:55:05
    Java 中操作文件的方法本质上只有两种:字符流和字节流,而字节流和字符流的实现类又有很多,因此在文件写入时我们就可以选择各种各样的类来实现。 流 Java 中的“流”是一种抽象的概念,也是一种比喻,就好比...
  • <p>EhCache 是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider。</p><p>主要的特性有: 1. 快速. 2. 简单. 3. 多种缓存策略 4. 缓存数据有两级:内存和磁盘,因此无需担心容量...
  • Caffeine 是一个基于Java 8的高性能本地缓存框架,其结构和 Guava Cache 基本一样,api也一样,基本上很容易就能替换。 Caffeine 实际上就是在 Guava Cache 的基础上,利用了一些 Java 8 的新特性,提高了某些场景下...
  • JAVA几种缓存技术介绍说明

    千次阅读 2021-03-04 09:50:37
    几个著名 Java 开源缓存框架介绍 (OSCache,JSC) 2009-07-3116:11 OSCache OSCache 是个一个广泛采用的高性能的 J2EE 缓存框架, OSCache 能用于任何 Java 应用程序的普通的缓存解决方案。 OSCache 有以下特点:缓存...
  • Java读取和写入二进制大文件的方法,应该说是一个基于二进制的大文件块,演示了如何自定义缓存区,并使用不具有缓冲功能的DataInputStream 和DataOutputStream 类来读写二进制的大文件块数据,运行效果请参见如下...
  • 使用Redis和Java进行数据库缓存

    千次阅读 2019-03-31 21:45:01
    数据库缓存是处理这些性能问题的最常见策略之一。缓存涉及将数据库查询的结果保存在更快,更容易访问的位置。正确完成后,缓存将减少查询响应时间,减少数据库负载并降低成本。 但是,缓存也需要小心处理,因为它们...
  • java中常用的缓存框架

    千次阅读 2019-10-10 23:05:04
    阅读文本大概需要3分钟。0x01:Ehcache Ehcache是一个Java实现的开源分布式缓存框架,EhCache可以有效地减轻数据库的负载,可以让数据保存在不同服...
  • Java缓存框架 Ehcache.zip

    2019-07-16 06:49:12
    EhCache 是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider。 下图是 Ehcache 在应用程序中的位置: 主要的特性有: 1. 快速.2. 简单.3. 多种缓存策略4. 缓存数据有两级:...
  • java基础-redis缓存

    千次阅读 2021-02-28 07:56:53
    AOF rewrite过程 Redis(fork)一个“重写子进程”,读取现有的AOF文件,并将其包含的指令进行分析压缩并写入到一个临时文件中 与此同时,主工作进程会将新接收到的写指令一边累积到内存缓冲区中,一边继续写入到...
  • Java缓存机制

    万次阅读 多人点赞 2018-08-21 02:53:25
    1 Java缓存 1.1 jvm内置缓存 Java中实现缓存的方式有很多,比如用static hashMap基于内存缓存的jvm内置缓存,简单不实用,保对象的有效性和周期无法控制,容易造成内存急剧上升。常用的有Oscache(主要针对jsp页面...
  • EhCache 是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider。 主要的特性有: 1. 快速. 2. 简单. 3. 多种缓存策略 4. 缓存数据有两级:内存和磁盘,因此无需担心...
  • 3. java缓存-线程内缓存guava cache

    千次阅读 2018-09-25 16:12:03
    guava cache的缓存结构 常用的guava cache缓存 根据上图中的缓存框架,我们常用的一些缓存实例有:LocalManualCache和LocalLoadingCache,两者唯一的区别就是LocalLoadingCache extends LocalManualCache ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 214,530
精华内容 85,812
关键字:

java 写入缓存

java 订阅