精华内容
下载资源
问答
  • Java输入输出

    万次阅读 多人点赞 2018-05-12 15:27:45
    引言:在平时java开发中,被输入输出搞得头疼。特此写下这篇博客,一是为了总结输入输出,二是为了和大家分享。如果大家觉得写得好,就请高抬贵手点个赞呗!!! 1.输入格式,输出格式控制 1.1输入处理 java的...

    源代码见:点击打开链接

    引言:在平时java开发中,被输入输出搞得头疼。特此写下这篇博客,一是为了总结输入输出,二是为了和大家分享。如果大家觉得写得好,就请高抬贵手点个赞呗!!!

    1.输入格式,输出格式控制

    1.1输入处理

        java的输入,我们用到Scanner类,可以用它创建一个对象

        Scanner reader=new Scanner(System.in);

        然后reader对象调用nextBoolean(),nextByte(),nextShort(),nextInt(),nextLong(),nextFloat(),nextDouble()方法来从输入流中获取数据。这些方法在执行时都会阻塞,程序等待用户在输入流中输入enter键(\n)时继续执行。这里的nextInt,hasNextInt()这些方法的调用,会判断当前字节流里面是否有东西,没有就阻塞等待输入直到用户按enter键(\n)结束输入,在Scanner类中有一个变量needInput,当需要读取数据时,needInput=true(也就是调用nextInt,hasNextInt()这些函数的时候)。有一个readInput方法,当字节流中有东西可读时,让needInput=false(表示不需要阻塞等待输入);下面是Scanner.class源码:

     // Tries to read more input. May block.
        private void readInput() {
            if (buf.limit() == buf.capacity())
                makeSpace();
    
            // Prepare to receive data
            int p = buf.position();
            buf.position(buf.limit());
            buf.limit(buf.capacity());
    
            int n = 0;
            try {
                n = source.read(buf);//这儿
            } catch (IOException ioe) {
                lastException = ioe;
                n = -1;//这儿
            }
    
            if (n == -1) {
                sourceClosed = true;
                needInput = false;//这儿
            }
    
            if (n > 0)
                needInput = false;/这儿
    
            // Restore current position and limit for reading
            buf.limit(buf.position());
            buf.position(p);
        }
    

        总之,在调用next(),hasNext()方法时,字节流里面有东西,就不用等待,没有东西就阻塞等待。例如:

    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Scanner s=new Scanner(System.in);
    		int a,b;
    		a=s.nextInt();
    		System.out.println(a);
    		b=s.nextInt();
    		System.out.println(b);
    		/*a=s.nextInt();
    		b=s.nextInt();
    		System.out.println(a+"  "+b);*/
    	}

        当在命令行时输入时,我可以这样输入(在一行就输入两个数据再按enter),当运行到b=s.nextInt()时,发现字节流里面有东西,就没有阻塞等待输入了。

        当然我们也可以这样输入(第一行输入2后,按enter键,然后在输入3,再按enter键)。运行过程是这样的,首先,当运行到a=s.nextInput()时发现,字节流里面没东西,等待输入,于是我们在命令行的第一行输入了2,按回车确认,这时程序继续执行。当运行到b=s.nextInt()时,发现字节流里面没东西,则阻塞等待输入,于是我们在命令行第三行输入3,按enter键确认,程序继续执行。

        Scanner 使用分隔符模式将其输入分解为标记,默认情况下该分隔符模式与空白匹配(当然可以自定义分隔符)。

         在下面1.3中我们举一个输入控制实例来熟练输入控制的使用。

     

    1.2 hasNext源码解析

    首先我们分输入源是System.in(也就是控制台),和从文件中读取(FileInputStream)。

    (1)对于System.in,不管如何都是要返回true的。我们看源码:

            /*这是测试代码*/
            Scanner scanner=new Scanner(System.in);
    
    
            while (scanner.hasNext()){
                System.out.println(scanner.next());
            }

     我们进入hasNext()函数

    
    public boolean hasNext() {
            ensureOpen();
            saveState();
            while (!sourceClosed) {
                /*看buffer里面是否有东西,有就返回ture*/
                if (hasTokenInBuffer())
                    return revertState(true);
                
                /*没有就从System.in中读入数据。该方法可能会阻塞*/
                readInput();
            }
            
            /*对于从控制台中读入数据,这两句代码是永远不会被执行的。相当于从控制台读入数据永远不会结束,sourceClosed永远为false*/
            boolean result = hasTokenInBuffer();
            return revertState(result);
    }

    (2) 从文件中读取(FileInputStream)

     Scanner scanner1=new Scanner(new FileInputStream("/home/fengli/a.txt"));
    
     while (scanner1.hasNext()){
           System.out.println(scanner1.next());
     }

     在进入hasNext()方法:

    public boolean hasNext() {
            ensureOpen();
            saveState();
            while (!sourceClosed) {
                /*看buffer里面是否有东西,有就返回ture*/
                if (hasTokenInBuffer())
                    return revertState(true);
                
                /*没有就从System.in中读入数据。该方法可能会阻塞*/
                readInput();
            }
            
            /*用文件中读取,sourceClosed就可能为ture。所以这个方法就可以返回false*/
            boolean result = hasTokenInBuffer();
            return revertState(result);
    }

     

    1.3 输出处理

        可用System.out.println()或System.out.print()来向屏幕进行输出。jdk1.5新增了和C语言中printf函数类似的数据输出方法,

    System.out.printf(“格式控制部分”,表达式1,表达式2,……,表达式n)

        格式控制部分由格式控制符号:%d,%c,%f,%s和普通字符组成,普通字符原样输出。格式控制符用来输出表达式的值。

        %d:输出int类型数据值

        %c:输出char类型数据

        %f:输出浮点型数据,小数点部分最多保留6位

        %s:输出字符串数据

        %md:输出int型数据占m列

        %m.nf:输出的浮点型数据占m列,小数点保留n位

    格式字符串语法:

        每个格式控制以%开始,以空格或标点符号结尾。

        

     

    1.3输入输出实例--读入指定形状,输出指定形状

        实例为输出九九乘法表,源码如下:

    public class Main {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		for(int i=1;i<=9;i++)
    		{
    			for(int j=1;j<=i;j++)
    			{
    				System.out.printf("%2d X%2d=%3d ",j,i,i*j);
    			}
    			System.out.println();
    		}
    	}
    }

        运行结果:

    2.从文件输入,输出

    2.1实现方法

        可通过重定向标准输入输出流的方法来实现从文件中输入输出数据。具体使用到的方法如下:

        

    static void setIn(InputStream in)//重定向标准输入
    static void setOut(PrintStream out) //重定向标准输出

       

    2.2从文件输入输出实例--拷贝

        通过重定向的方法,实现从一个文件拷贝东西到另外一个文件。

        代码如下:

    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.PrintStream;
    import java.util.Scanner;
    
    public class Main {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		/*
    		 * FileInputStream里面的路径可以写绝对路径又可以写相对路径,为了程序的移植性,推荐使用相对路径,相对路径
    		 * 的根路径是Copy
    		 */
    		FileInputStream fis = null;
    		PrintStream fos=null;
    		try {
    			fis = new FileInputStream("src/source");
    			fos=new PrintStream("src/dest");
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		System.setIn(fis);//重定向标准输入
    		
    		//接下来就和从标准输入流读入数据一样了
    		Scanner sc = new Scanner(System.in);
    		String s=sc.nextLine();
    		System.out.println(s);
    		
    		//重定向输出流
    		System.setOut(fos);
    		
    		//接下来就和从标准输出流读入数据一样了
    		System.out.println(s);
    	}
    
    }
    

     

     

     

     

     

     

     

     

     

    展开全文
  • 效果展示完成对这些信息获取主要还是利用redis的一些命令,如果是win系统下安装的redis,在安装目录运行redis-cli.exe这个文件,输入info,再回车,就可以看到输出很多字段的参数,部分具体参数对应的意思如下: ...

    效果展示


    实时监控

    redis环境信息和日志列表

    Redis配置


    在windows下安装的redis,在安装目录找到redis.windows.conf文件,修改以下字段(按实际情况设置):

    slowlog-log-slower-than 100
    
    slowlog-max-len 1000000

    slowlog-log-slower-than:是配置需要日志记录的命令执行时间,单位是微秒,也就是说配置为100,会记录命令执行时间为0.1ms以上的记录。如果设置为0,就会记录所有执行过的命令。

    slowlog-max-len:是配置日志记录的条数,因为这个日志也是存储在内存中的,所以不需要担心记录日志会影响性能,但是会消耗一定内存。

    完成对这些信息的获取主要还是利用redis的一些命令,如果是win系统下安装的redis,在安装目录运行redis-cli.exe这个文件,输入info,再回车,就可以看到输出很多字段的参数,部分具体参数对应的意思如下:

    • server : 一般 Redis 服务器信息,包含以下域:
    • redis_version : Redis 服务器版本
    • redis_git_sha1 : Git SHA1
    • redis_git_dirty : Git dirty flag
    • os : Redis 服务器的宿主操作系统
    • arch_bits : 架构(32 或 64 位)
    • multiplexing_api : Redis 所使用的事件处理机制
    • gcc_version : 编译 Redis 时所使用的 GCC 版本
    • process_id : 服务器进程的 PID
    • run_id : Redis 服务器的随机标识符(用于 Sentinel 和集群)
    • tcp_port : TCP/IP 监听端口
    • uptime_in_seconds : 自 Redis 服务器启动以来,经过的秒数
    • uptime_in_days : 自 Redis 服务器启动以来,经过的天数
    • lru_clock : 以分钟为单位进行自增的时钟,用于 LRU 管理
    • clients : 已连接客户端信息,包含以下域:
    • connected_clients : 已连接客户端的数量(不包括通过从属服务器连接的客户端)
    • client_longest_output_list : 当前连接的客户端当中,最长的输出列表
    • client_longest_input_buf : 当前连接的客户端当中,最大输入缓存
    • blocked_clients : 正在等待阻塞命令(BLPOP、BRPOP、BRPOPLPUSH)的客户端的数量
    • memory : 内存信息,包含以下域:
    • used_memory : 由 Redis 分配器分配的内存总量,以字节(byte)为单位
    • used_memory_human : 以人类可读的格式返回 Redis 分配的内存总量
    • used_memory_rss : 从操作系统的角度,返回 Redis 已分配的内存总量(俗称常驻集大小)。这个值和 top 、 ps 等命令的输出一致。
    • used_memory_peak : Redis 的内存消耗峰值(以字节为单位)
    • used_memory_peak_human : 以人类可读的格式返回 Redis 的内存消耗峰值
    • used_memory_lua : Lua 引擎所使用的内存大小(以字节为单位)
    • mem_fragmentation_ratio : used_memory_rss 和 used_memory 之间的比率
    • mem_allocator : 在编译时指定的, Redis 所使用的内存分配器。可以是 libc 、 jemalloc 或者 tcmalloc 。
      在理想情况下, used_memory_rss 的值应该只比 used_memory 稍微高一点儿。
      当 rss > used ,且两者的值相差较大时,表示存在(内部或外部的)内存碎片。
      内存碎片的比率可以通过 mem_fragmentation_ratio 的值看出。
      当 used > rss 时,表示 Redis 的部分内存被操作系统换出到交换空间了,在这种情况下,操作可能会产生明显的延迟。
      当 Redis 释放内存时,分配器可能会,也可能不会,将内存返还给操作系统。
      如果 Redis 释放了内存,却没有将内存返还给操作系统,那么 used_memory 的值可能和操作系统显示的 Redis 内存占用并不一致。
      查看 used_memory_peak 的值可以验证这种情况是否发生。
    • persistence : RDB 和 AOF 的相关信息
    • stats : 一般统计信息
    • replication : 主/从复制信息
    • cpu : CPU 计算量统计信息
    • commandstats : Redis 命令统计信息
    • cluster : Redis 集群信息
    • keyspace : 数据库相关的统计信息

    java部分代码实现


    上面是命令窗的方式,使用java的话,我们就是借助jedis这个框架来帮我们完成:

    @Component
    public class RedisUtil {
    
        @Autowired
        JedisPool jedisPool;
    
        // 获取redis 服务器信息
        public String getRedisInfo() {
    
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                Client client = jedis.getClient();
                client.info();
                String info = client.getBulkReply();
                return info;
            } finally {
                // 返还到连接池
                jedis.close();
            }
        }
    
        // 获取日志列表
        public List<Slowlog> getLogs(long entries) {
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                List<Slowlog> logList = jedis.slowlogGet(entries);
                return logList;
            } finally {
                // 返还到连接池
                jedis.close();
            }
        }
    
        // 获取日志条数
        public Long getLogsLen() {
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                long logLen = jedis.slowlogLen();
                return logLen;
            } finally {
                // 返还到连接池
                jedis.close();
            }
        }
    
        // 清空日志
        public String logEmpty() {
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                return jedis.slowlogReset();
            } finally {
                // 返还到连接池
                jedis.close();
            }
        }
    
        // 获取占用内存大小
        public Long dbSize() {
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                // TODO 配置redis服务信息
                Client client = jedis.getClient();
                client.dbSize();
                return client.getIntegerReply();
            } finally {
                // 返还到连接池
                jedis.close();
            }
        }
    }
    

    这样输出的都是和控制台一样的字符串,所以还需要sevice来对数据进行封装:

    @Service
    public class RedisService {
    
        @Autowired
        RedisUtil redisUtil;
    
        public List<RedisInfoDetail> getRedisInfo() {
            //获取redis服务器信息
            String info = redisUtil.getRedisInfo();
            List<RedisInfoDetail> ridList = new ArrayList<RedisInfoDetail>();
            String[] strs = info.split("\n");
            RedisInfoDetail rif = null;
            if (strs != null && strs.length > 0) {
                for (int i = 0; i < strs.length; i++) {
                    rif = new RedisInfoDetail();
                    String s = strs[i];
                    String[] str = s.split(":");
                    if (str != null && str.length > 1) {
                        String key = str[0];
                        String value = str[1];
                        rif.setKey(key);
                        rif.setValue(value);
                        ridList.add(rif);
                    }
                }
            }
            return ridList;
        }
    
        //获取redis日志列表
        public List<Operate> getLogs(long entries) {
            List<Slowlog> list = redisUtil.getLogs(entries);
            List<Operate> opList = null;
            Operate op  = null;
            boolean flag = false;
            if (list != null && list.size() > 0) {
                opList = new LinkedList<Operate>();
                for (Slowlog sl : list) {
                    String args = JSON.toJSONString(sl.getArgs());
                    if (args.equals("[\"PING\"]") || args.equals("[\"SLOWLOG\",\"get\"]") || args.equals("[\"DBSIZE\"]") || args.equals("[\"INFO\"]")) {
                        continue;
                    }   
                    op = new Operate();
                    flag = true;
                    op.setId(sl.getId());
                    op.setExecuteTime(getDateStr(sl.getTimeStamp() * 1000));
                    op.setUsedTime(sl.getExecutionTime()/1000.0 + "ms");
                    op.setArgs(args);
                    opList.add(op);
                }
            } 
            if (flag) 
                return opList;
            else 
                return null;
        }
        //获取日志总数
        public Long getLogLen() {
            return redisUtil.getLogsLen();
        }
    
        //清空日志
        public String logEmpty() {
            return redisUtil.logEmpty();
        }
        //获取当前数据库中key的数量
        public Map<String,Object> getKeysSize() {
            long dbSize = redisUtil.dbSize();
            Map<String,Object> map = new HashMap<String, Object>();
            map.put("create_time", new Date().getTime());
            map.put("dbSize", dbSize);
            return map;
        }
    
        //获取当前redis使用内存大小情况
        public Map<String,Object> getMemeryInfo() {
            String[] strs = redisUtil.getRedisInfo().split("\n");
            Map<String, Object> map = null;
            for (int i = 0; i < strs.length; i++) {
                String s = strs[i];
                String[] detail = s.split(":");
                if (detail[0].equals("used_memory")) {
                    map = new HashMap<String, Object>();
                    map.put("used_memory",detail[1].substring(0, detail[1].length() - 1));
                    map.put("create_time", new Date().getTime());
                    break;
                }
            }
            return map;
        }
        private String getDateStr(long timeStmp) {
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            return dateFormat.format(new Date(timeStmp));
        }
    }
    

    上面我只是贴了部分核心代码,想具体去了解的可以去下载我的项目跑一下。

    由于这个没有什么难度,只是就只是贴了些代码。后续也会一直更新,一步步将这个系统完善起来。

    ·······················································································································································

    个人博客:http://z77z.oschina.io/

    此项目下载地址:https://git.oschina.net/z77z/springboot_mybatisplus

    ·······················································································································································

    展开全文
  • Redis配置 在windows下安装的redis,在安装目录找到 redis.windows.conf 文件,修改以下字段(按实际情况设置): ...转自【http://z77z.oschina.io/2017/04/04/java获取redis的日志信息动态监控信息/】
    Redis配置
    

    在windows下安装的redis,在安装目录找到 redis.windows.conf 文件,修改以下字段(按实际情况设置):

    slowlog-log-slower-than 100

    slowlog-max-len 1000000

    slowlog-log-slower-than:是配置需要日志记录的命令执行时间,单位是微秒,也就是说配置为100,会记录命令执行时间为0.1ms以上的记录。如果设置为0,就会记录所有执行过的命令。

    slowlog-max-len:是配置日志记录的条数,因为这个日志也是存储在内存中的,所以不需要担心记录日志会影响性能,但是会消耗一定内存。

    完成对这些信息的获取主要还是利用redis的一些命令,如果是win系统下安装的redis,在安装目录运行 redis-cli.exe 这个文件,输入 info ,再回车,就可以看到输出很多字段的参数,部分具体参数对应的意思如下:

    • server : 一般 Redis 服务器信息,包含以下域:
    • redis_version : Redis 服务器版本
    • redis_git_sha1 : Git SHA1
    • redis_git_dirty : Git dirty flag
    • os : Redis 服务器的宿主操作系统
    • arch_bits : 架构(32 或 64 位)
    • multiplexing_api : Redis 所使用的事件处理机制
    • gcc_version : 编译 Redis 时所使用的 GCC 版本
    • process_id : 服务器进程的 PID
    • run_id : Redis 服务器的随机标识符(用于 Sentinel 和集群)
    • tcp_port : TCP/IP 监听端口
    • uptime_in_seconds : 自 Redis 服务器启动以来,经过的秒数
    • uptime_in_days : 自 Redis 服务器启动以来,经过的天数
    • lru_clock : 以分钟为单位进行自增的时钟,用于 LRU 管理
    • clients : 已连接客户端信息,包含以下域:
    • connected_clients : 已连接客户端的数量(不包括通过从属服务器连接的客户端)
    • client_longest_output_list : 当前连接的客户端当中,最长的输出列表
    • client_longest_input_buf : 当前连接的客户端当中,最大输入缓存
    • blocked_clients : 正在等待阻塞命令(BLPOP、BRPOP、BRPOPLPUSH)的客户端的数量
    • memory : 内存信息,包含以下域:
    • used_memory : 由 Redis 分配器分配的内存总量,以字节(byte)为单位
    • used_memory_human : 以人类可读的格式返回 Redis 分配的内存总量
    • used_memory_rss : 从操作系统的角度,返回 Redis 已分配的内存总量(俗称常驻集大小)。这个值和 top 、 ps 等命令的输出一致。
    • used_memory_peak : Redis 的内存消耗峰值(以字节为单位)
    • used_memory_peak_human : 以人类可读的格式返回 Redis 的内存消耗峰值
    • used_memory_lua : Lua 引擎所使用的内存大小(以字节为单位)
    • mem_fragmentation_ratio : used_memory_rss 和 used_memory 之间的比率
    • mem_allocator : 在编译时指定的, Redis 所使用的内存分配器。可以是 libc 、 jemalloc 或者 tcmalloc 。
    在理想情况下, used_memory_rss 的值应该只比 used_memory 稍微高一点儿。
    当 rss > used ,且两者的值相差较大时,表示存在(内部或外部的)内存碎片。
    内存碎片的比率可以通过 mem_fragmentation_ratio 的值看出。
    当 used > rss 时,表示 Redis 的部分内存被操作系统换出到交换空间了,在这种情况下,操作可能会产生明显的延迟。
    当 Redis 释放内存时,分配器可能会,也可能不会,将内存返还给操作系统。
    如果 Redis 释放了内存,却没有将内存返还给操作系统,那么 used_memory 的值可能和操作系统显示的 Redis 内存占用并不一致。
    查看 used_memory_peak 的值可以验证这种情况是否发生。
    • persistence : RDB 和 AOF 的相关信息
    • stats : 一般统计信息
    • replication : 主/从复制信息
    • cpu : CPU 计算量统计信息
    • commandstats : Redis 命令统计信息
    • cluster : Redis 集群信息
    • keyspace : 数据库相关的统计信息

    java部分代码实现

    上面是命令窗的方式,使用java的话,我们就是借助jedis这个框架来帮我们完成:

    @Component
    public classRedisUtil{
    
    	@Autowired
    	JedisPool jedisPool;
    
    	// 获取redis 服务器信息
    	publicStringgetRedisInfo(){
    
    		Jedis jedis = null;
    		try {
    			jedis = jedisPool.getResource();
    			Client client = jedis.getClient();
    			client.info();
    			String info = client.getBulkReply();
    			return info;
    		} finally {
    			// 返还到连接池
    			jedis.close();
    		}
    	}
    
    	// 获取日志列表
    	publicList<Slowlog>getLogs(longentries){
    		Jedis jedis = null;
    		try {
    			jedis = jedisPool.getResource();
    			List<Slowlog> logList = jedis.slowlogGet(entries);
    			return logList;
    		} finally {
    			// 返还到连接池
    			jedis.close();
    		}
    	}
    
    	// 获取日志条数
    	publicLonggetLogsLen(){
    		Jedis jedis = null;
    		try {
    			jedis = jedisPool.getResource();
    			long logLen = jedis.slowlogLen();
    			return logLen;
    		} finally {
    			// 返还到连接池
    			jedis.close();
    		}
    	}
    
    	// 清空日志
    	publicStringlogEmpty(){
    		Jedis jedis = null;
    		try {
    			jedis = jedisPool.getResource();
    			return jedis.slowlogReset();
    		} finally {
    			// 返还到连接池
    			jedis.close();
    		}
    	}
    
    	// 获取占用内存大小
    	publicLongdbSize(){
    		Jedis jedis = null;
    		try {
    			jedis = jedisPool.getResource();
    			// TODO 配置redis服务信息
    			Client client = jedis.getClient();
    			client.dbSize();
    			return client.getIntegerReply();
    		} finally {
    			// 返还到连接池
    			jedis.close();
    		}
    	}
    }

    这样输出的都是和控制台一样的字符串,所以还需要sevice来对数据进行封装:

    @Service
    public classRedisService{
    	
    	@Autowired
    	RedisUtil redisUtil;
    	
    	publicList<RedisInfoDetail>getRedisInfo(){
    		//获取redis服务器信息
    		String info = redisUtil.getRedisInfo();
    		List<RedisInfoDetail> ridList = new ArrayList<RedisInfoDetail>();
    		String[] strs = info.split("\n");
    		RedisInfoDetail rif = null;
    		if (strs != null && strs.length > 0) {
    			for (int i = 0; i < strs.length; i++) {
    				rif = new RedisInfoDetail();
    				String s = strs[i];
    				String[] str = s.split(":");
    				if (str != null && str.length > 1) {
    					String key = str[0];
    					String value = str[1];
    					rif.setKey(key);
    					rif.setValue(value);
    					ridList.add(rif);
    				}
    			}
    		}
    		return ridList;
    	}
    	
    	//获取redis日志列表
    	publicList<Operate>getLogs(longentries){
            List<Slowlog> list = redisUtil.getLogs(entries);
    		List<Operate> opList = null;
    		Operate op  = null;
    		boolean flag = false;
    		if (list != null && list.size() > 0) {
    			opList = new LinkedList<Operate>();
    			for (Slowlog sl : list) {
    				String args = JSON.toJSONString(sl.getArgs());
    				if (args.equals("[\"PING\"]") || args.equals("[\"SLOWLOG\",\"get\"]") || args.equals("[\"DBSIZE\"]") || args.equals("[\"INFO\"]")) {
    					continue;
    				}	
    				op = new Operate();
    				flag = true;
    				op.setId(sl.getId());
    				op.setExecuteTime(getDateStr(sl.getTimeStamp() * 1000));
    				op.setUsedTime(sl.getExecutionTime()/1000.0 + "ms");
    				op.setArgs(args);
    				opList.add(op);
    			}
    		} 
    		if (flag) 
    			return opList;
    		else 
    			return null;
    	}
    	//获取日志总数
    	publicLonggetLogLen(){
    		return redisUtil.getLogsLen();
    	}
    	
    	//清空日志
    	publicStringlogEmpty(){
    		return redisUtil.logEmpty();
    	}
    	//获取当前数据库中key的数量
    	publicMap<String,Object>getKeysSize(){
    		long dbSize = redisUtil.dbSize();
    		Map<String,Object> map = new HashMap<String, Object>();
    		map.put("create_time", new Date().getTime());
    		map.put("dbSize", dbSize);
    		return map;
    	}
    	
    	//获取当前redis使用内存大小情况
    	publicMap<String,Object>getMemeryInfo(){
    		String[] strs = redisUtil.getRedisInfo().split("\n");
    		Map<String, Object> map = null;
    		for (int i = 0; i < strs.length; i++) {
    			String s = strs[i];
    			String[] detail = s.split(":");
    			if (detail[0].equals("used_memory")) {
    				map = new HashMap<String, Object>();
    				map.put("used_memory",detail[1].substring(0, detail[1].length() - 1));
    				map.put("create_time", new Date().getTime());
    				break;
    			}
    		}
    		return map;
    	}
    	privateStringgetDateStr(longtimeStmp){
    		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		return dateFormat.format(new Date(timeStmp));
    	}
    }

    上面我只是贴了部分核心代码,想具体去了解的可以去下载我的项目跑一下。


    转自【http://z77z.oschina.io/2017/04/04/java获取redis的日志信息和动态监控信息/】

    展开全文
  • 数字证书:从文件中读取数字证书,生成文件输入流,输入文件为c:/mycert.cer,获取一个处理X.509证书的证书工厂…… Java+ajax写的登录实例 1个目标文件 内容索引:Java源码,初学实例,ajax,登录 一个Java+ajax写的...
  • Java项目中,或多或少我们有动态执行代码的需求,比如: 系统中有一个规则验证需求,但规则经常改变 代码热更新,热修复 笔者也在目前参与的一个项目中遇到了动态执行代码的需求:项目需要一个自动审核模块,...

    引言

    在Java项目中,或多或少我们有动态执行代码的需求,比如:

    • 系统中有一个规则验证需求,但规则经常改变
    • 代码热更新,热修复

    笔者也在目前参与的一个项目中遇到了动态执行代码的需求:项目需要一个自动审核模块,但是审核规则根据相关书面文件制定,如果写死在.java文件里,那么当新的书面文件下发时,就要系统停机更新系统,然后才能继续使用,其中存在着很多不稳定因素,也很麻烦。因此在设计上就有动态执行代码的需求。好在这个需求只是审核一个表单,并没有对系统的操作和IO操作,输入参数也很固定。

    笔者上网查阅了大量资料,发现网上大致流传三种动态执行代码方式,笔者经过全面比较,选择了其中一种。这里将几种方法列举如下。

    方法

    1.使用JEXL动态执行表达式

    参考利用JEXL实现动态表达式编译 - Narcssus的专栏 - CSDN博客

    JEXL支持两种循环方式:

    for(item : list) {
        x = x + item;
    }
    

    while (x lt 10) {
        x = x + 2;
    }
    
    • 优点:可以动态执行Java代码,调用Java Function(Function需先传入JexlContext)
    • 缺点:只能执行一个“表达式”,而不是Function,所以有很多语法局限,不是真正执行一个Function

    2.使用Java动态编译

    参考[改善Java代码]慎用动态编译 - SummerChill - 博客园

    动态编译一直是Java的梦想,从Java 6版本它开始支持动态编译了,可以在运行期直接编译.java文件,执行.class,并且能够获得相关的输入输出,甚至还能监听相关的事件。不过,我们最期望的还是给定一段代码,直接编译,然后运行,也就是空中编译执行(on-the-fly)。

    • 优点:功能强大,能够真正实现完整的动态执行功能,能够动态调用全部系统功能和IO操作。
    • 缺点:虽然功能强大,可以编译.java文件,但是还是很难在运行时替换框架级的类文件,但是相比于上述方法已经有过之而无不及了;能动态调用全部系统功能和IO操作,与一般代码环境没有隔离,从而会成为项目中一个非常严重的安全隐患处。

    3.使用Java ScriptEngine

    使用Java自带的ScriptEngine可以说是最完美的Java动态执行代码方案之一(不考虑代码热更新等场景),关于ScriptEngine网上有大量资料可供参考,这里就不附参考资料了,简单提供下一个使用JS Engine的例子:

    String regular="function regular(args1,args2,args3){................}";
    ScriptEngine engine = new ScriptEngineManager().getEngineByName("javascript");
    try {
    	engine.eval(regular);
    	if (engine instanceof Invocable) {
    		Invocable invoke = (Invocable) engine;
    		String result = (String) invoke.invokeFunction(
    				"regular", 
    				args1,
    				args2,
    				args3);
    		System.out.println(result);
    		} else {
    			System.out.println("error");
    		}
    	}
    } catch (ScriptException e) {
    	System.out.println("表达式runtime错误:" + e.getMessage());
    }
    

    使用eval(),动态执行一遍JS代码(包含一个JS function),然后利用Java的Invoke传入参数,最后获取返回值。

    • 优点:可以执行完整的JS方法,并且获取返回值;在虚拟的Context中执行,无法调用系统操作和IO操作,非常安全;可以有多种优化方式,可以预编译,编译后可以复用,效率接近原生Java;所有实现ScriptEngine接口的语言都可以使用,并不仅限于JS,如Groovy,Ruby等语言都可以动态执行。
    • 缺点:无法调用系统和IO操作 ,也不能使用相关js库,只能使用js的标准语法。更新:可以使用scriptengine.put()将Java原生Object传入Context,从而拓展实现调用系统和IO等操作。

    对于一般的动态执行代码需求,建议使用最后一种方法。

    展开全文
  • Java编程:获取键盘输入的三种方法

    万次阅读 2016-07-28 17:52:48
    方法一:使用System.out.read()获取键盘输入,此方法只能一个字符一个字符的获取获取到的变量类型为int,需要通过类型转换获取到自己期望的类型。该方法也会接收回车符(13)、换行符(10)。package ...
  • java Socket双向交互获取输入信息

    千次阅读 2015-04-22 06:36:56
    java socket获取信息 信息来源 http://my.oschina.net/leejun2005/blog/104955 public class SocketClient {  public static void main(String[] args) {  try {  /** 创建Socket*/
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的...
  • 用户输入一组整数,中间以空格分隔,点计算,会输出最小的数,执行代码如下: import java.awt.EventQueue; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing....
  • 本地cmd命令, 输入命令, 并在控制台输出命令执行结果 jsch 远程ssh到linux服务器, 执行结果并显示输出
  • JAVA执行shell脚本并实时获取输出

    万次阅读 2018-08-20 20:16:30
    个人博客原文地址:http://www.ltang.me/2016/10/23/java-call-shell/ ...简单的思路就是,页面通过websocket连接到java后台,java代码调用shell脚本执行发布操作,获取输出,并通过websocket将输出内容返回页面。 ...
  • jsch通过java代码ssh登录主机远程执行命令并返回结果。注意,这个是源代码,请自行编译后在使用。当然,也可以根据自己的需要更改源代码。
  • ``` //运行一个已经编译过的java文件,FinalUtils.coderun是“java test“,FinalUtils.file是命令运行的所在文件夹 ...如何在获取,"输入a:"的信息后,然后再获取"a="的信息呢 ,,而不是一次性获取
  • java获取控制台输入的两种方式

    万次阅读 2016-08-24 19:35:37
    第一种方式:比较传统的方式,得到字符串后要另行判断...import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class MainRun { /** * @param args */
  • java获取用户的输出信息

    千次阅读 2015-11-19 21:14:58
    package abc; import java.util.Scanner;//导入java.util.Scanner /* * 功能:为指定的成绩进行... * 使用Scanner工具类来获取用户输入的成绩信息 * Scanner类位于java.util包中,使用时需要导入此包 * 步骤: * 1.
  • Java 执行cmd程序,并获取命令行内容

    万次阅读 2018-02-27 15:53:23
    java中的RunTime类,每个java程序都有一个RunTme的运行实例,...Process 的 getInputStream() 会获取窗体命令执行的结果,可以把它转化成字符串进行输出。下面是具体的实现代码: import java.io.BufferedReader...
  • java调用Linux命令获取输出流,用于解决获取不到输出流的方法
  • java 用户输入加减乘除表达式运算,用户输入解析部分很好用
  • Java面试题大全(2020版)

    万次阅读 多人点赞 2019-11-26 11:59:06
    发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~ 本套Java面试题大全,全的不能再全,哈哈~ 一、Java 基础 1. JDK 和 JRE 有什么区别? JDK:Java ...
  • Java获取键盘输入值的三种方法

    千次阅读 2016-09-18 22:42:00
    笔者决定出一个java基础系列的博文,记录本次复习的总结。 原文出处: http://blog.sina.com.cn/s/blog_93dc666c0101h00f.html 一、调用System.in.read()方法import java.io.*; public static void main(String [] ...
  • 程序如何动态编译输入的代码并运行?! 如果对runtime.exec方法不了解建议先行阅读上篇文章。 好的,进入正题,我们先来看看Process类在API中的解释: java.lang 类 Process java.lang.Object java.lang....
  • 使用Scanner来取得使用者的输入很方便,但是它以空白来区隔每一个输入字符串,在某些时候并不适用,因为使用者可能输入一个字符串,中间会包括空白字元,而您希望取得完整的字符串。 您可以使用BufferedReader...
  • java获取键盘输入的数字,并进行排序

    万次阅读 2016-12-19 22:35:48
    需求:由键盘输入三个整数分别存入变量num1、num2、num3,对它们进行排序, 并且从小到大输出 可以使用2种方法实现:一、使用if-else分支结构;二、使用java内置模块Arrays的排序方法。
  • java执行原始码命令执行库 它是一个库,您可以在其中输入cmd命令并从Java源代码中获取结果值。 测试代码-----
  • java在使用Runtime获取Process输入流阻塞问题 问题描述: Process ps= Runtime().getRuntime().exec(command);返回Process 需要手动处理getInputStream()和getErrorStream(),两者都需要处理,要是不处理的话,会造成...
  • 1.Windows/Linux环境下查看Java进程ID方法使用Java自带的工具VisualVM工具实现,在CMD或者是Linux终端下执行“jvisualvm”命令即可以进入VisualVM控制台,双击左侧的进程即可以查看到详细的信息。2.生成DUMP文件CMD...
  • 因为,没人要我的原因是我没有java的基础,虽然对android了解一些,但是,没有java基础,有的公司会很难考虑你,鉴于这点,我又开始学java基础,不图精深。但求基础就行。这样我就能找到一个android的工作了。 ...
  • Python如何获取用户输入

    万次阅读 多人点赞 2019-08-20 22:40:26
    有时候,我们编写的程序需要从用户那儿“拿到”一些数据才能继续执行下去,比如,判断某人是否到了法定投票年龄,需要用户自己输入名字和年龄才行。 Python要“拿到”用户输入的数据比起Java来可简单多了,只需要...
  • 使用Java代码运行系统命令/shell命令, 并获取输出结果。
  • java语言中获取用户输入的语句

    千次阅读 2012-05-16 17:26:29
    在编写java代码时,有时候需要手工输入参数与程序互动,代码执行完下面这句后,便可以输入参数,回车后,代码将会继续往下执行。 System.in.read();

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 392,766
精华内容 157,106
关键字:

java获取用户输入信息动态执行

java 订阅