IO整体图架构

 一、IO流概述

概述:

IO流简单来说就是Input和Output流,IO流主要是用来处理设备之间的数据传输,Java对于数据的操作都是通过流实现,而java用于操作流的对象都在IO包中。

分类:

按操作数据分为:字节流和字符流。 如:Reader和InpurStream

按流向分:输入流和输出流。如:InputStream和OutputStream

IO流常用的基类:

* InputStream    ,    OutputStream

字符流的抽象基类:

* Reader       ,         Writer

由上面四个类派生的子类名称都是以其父类名作为子类的后缀:

如:FileReader和FileInputStream

二、字符流

1. 字符流简介:

* 字符流中的对象融合了编码表,也就是系统默认的编码表。我们的系统一般都是GBK编码。

* 字符流只用来处理文本数据,字节流用来处理媒体数据。

* 数据最常见的表现方式是文件,字符流用于操作文件的子类一般是FileReader和FileWriter。

2.字符流读写:

注意事项:

* 写入文件后必须要用flush()刷新。

* 用完流后记得要关闭流

* 使用流对象要抛出IO异常

* 定义文件路径时,可以用“/”或者“\\”。

* 在创建一个文件时,如果目录下有同名文件将被覆盖。

* 在读取文件时,必须保证该文件已存在,否则出异常

示例1:在硬盘上创建一个文件,并写入一些文字数据

  1. class FireWriterDemo {  
  2. public static void main(String[] args) throws IOException {             //需要对IO异常进行处理   
  3. //创建一个FileWriter对象,该对象一被初始化就必须要明确被操作的文件。
  4. //而且该文件会被创建到指定目录下。如果该目录有同名文件,那么该文件将被覆盖。
  5. FileWriter fw = new FileWriter("F:\\1.txt");//目的是明确数据要存放的目的地。  
  6. //调用write的方法将字符串写到流中
  7. fw.write("hello world!");
  8. //刷新流对象缓冲中的数据,将数据刷到目的地中
  9. fw.flush();
  10. //关闭流资源,但是关闭之前会刷新一次内部缓冲中的数据。当我们结束输入时候,必须close();
  11. fw.write("first_test");
  12. fw.close();
  13. //flush和close的区别:flush刷新后可以继续输入,close刷新后不能继续输入。
  14. }
  15. }

示例2:FileReader的reade()方法.

要求:用单个字符和字符数组进行分别读取

  1. class FileReaderDemo {  
  2. public static void main(String[] args) {  
  3. characters();
  4. }
  5. /*****************字符数组进行读取*********************/
  6. private static void characters() {  
  7. try {  
  8. FileReader fr = new FileReader("Demo.txt");  
  9. char []  buf = new char[6];   
  10. //将Denmo中的文件读取到buf数组中。
  11. int num = 0;      
  12. while((num = fr.read(buf))!=-1) {  
  13. //String(char[] value , int offest,int count) 分配一个新的String,包含从offest开始的count个字符
  14. sop(new String(buf,0,num));  
  15. }
  16. sop('\n');
  17. fr.close();
  18. }
  19. catch (IOException e) {  
  20. sop(e.toString());
  21. }
  22. }
  23. /*****************单个字母读取*************************/
  24. private static void singleReader() {  
  25. try {  
  26. //创建一个文件读取流对象,和指定名称的文件关联。
  27. //要保证文件已经存在,否则会发生异常:FileNotFoundException
  28. FileReader fr = new FileReader("Demo.txt");  
  29. //如何调用读取流对象的read方法?
  30. //read()方法,一次读取一个字符,并且自动往下读。如果到达末尾则返回-1
  31. int ch = 0;  
  32. while ((ch=fr.read())!=-1) {  
  33. sop((char)ch);  
  34. }
  35. sop('\n');
  36. fr.close();
  37. /*int ch = fr.read();
  38. sop("ch=" + (char)ch);
  39. int ch2 = fr.read();
  40. sop("ch2=" + (char)ch2);
  41. //使用结束注意关闭流
  42. fr.close(); */
  43. }
  44. catch (IOException e) {  
  45. sop(e.toString());
  46. }
  47. }
  48. /**********************Println************************/
  49. private static void sop(Object obj) {  
  50. System.out.print(obj);
  51. }
  52. }

示例3:对已有文件的数据进行续写

[java] view plain copy

  1. import java.io.*;  
  2. class  FileWriterDemo3 {  
  3. public static void main(String[] args) {  
  4. try {  
  5. //传递一个参数,代表不覆盖已有的数据。并在已有数据的末尾进行数据续写
  6. FileWriter fw = new FileWriter("F:\\java_Demo\\day9_24\\demo.txt",true);  
  7. fw.write(" is charactor table?");
  8. fw.close();
  9. }
  10. catch (IOException e) {  
  11. sop(e.toString());
  12. }
  13. }
  14. /**********************Println************************/
  15. private static void sop(Object obj)  
  16. {
  17. System.out.println(obj);
  18. }
  19. }

三、缓冲区

1. 字符流的缓冲区:BufferedReader和BufferedWreiter

* 缓冲区的出现时为了提高流的操作效率而出现的.

* 需要被提高效率的流作为参数传递给缓冲区的构造函数

* 在缓冲区中封装了一个数组,存入数据后一次取出

BufferedReader示例:

读取流缓冲区提供了一个一次读一行的方法readline,方便对文本数据的获取。
readline()只返回回车符前面的字符,不返回回车符。如果是复制的话,必须加入newLine(),写入回车符

newLine()是java提供的多平台换行符写入方法。

  1. import java.io.*;  
  2. class BufferedReaderDemo {  
  3. public static void main(String[] args)  throws IOException {  
  4. //创建一个字符读取流流对象,和文件关联
  5. FileReader rw = new FileReader("buf.txt");  
  6. //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可
  7. BufferedReader brw = new BufferedReader(rw);  
  8. for(;;) {  
  9. String s = brw.readLine();
  10. if(s==null) break;  
  11. System.out.println(s);
  12. }
  13. brw.close();//关闭输入流对象
  14. }
  15. }

BufferedWriter示例:

  1. import java.io.*;  
  2. class BufferedWriterDemo {  
  3. public static void main(String[] args)  throws IOException {  
  4. //创建一个字符写入流对象
  5. FileWriter fw = new FileWriter("buf.txt");  
  6. //为了提高字符写入效率,加入了缓冲技术。
  7. //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可
  8. BufferedWriter bfw = new BufferedWriter(fw);  
  9. //bfw.write("abc\r\nde");
  10. //bfw.newLine();               这行代码等价于bfw.write("\r\n"),相当于一个跨平台的换行符
  11. //用到缓冲区就必须要刷新
  12. for(int x = 1; x < 5; x++) {  
  13. bfw.write("abc");
  14. bfw.newLine();                  //java提供了一个跨平台的换行符newLine();
  15. bfw.flush();
  16. }
  17. bfw.flush();                                                //刷新缓冲区
  18. bfw.close();                                                //关闭缓冲区,但是必须要先刷新
  19. //注意,关闭缓冲区就是在关闭缓冲中的流对象
  20. fw.close();                                                 //关闭输入流对象
  21. }
  22. }

 

四、字节流

1.概述:

1、字节流和字符流的基本操作是相同的,但是要想操作媒体流就需要用到字节流。

2、字节流因为操作的是字节,所以可以用来操作媒体文件。(媒体文件也是以字节存储的)

3、读写字节流:InputStream   输入流(读)和OutputStream  输出流(写)

4、字节流操作可以不用刷新流操作。

5、InputStream特有方法:

int available();//返回文件中的字节个数

注:可以利用此方法来指定读取方式中传入数组的长度,从而省去循环判断。但是如果文件较大,而虚拟机启动分配的默认内存一般为64M。当文件过大时,此数组长度所占内存空间就会溢出。所以,此方法慎用,当文件不大时,可以使用。

练习:

需求:复制一张图片F:\java_Demo\day9_28\1.BMP到F:\java_Demo\day9_28\2.bmp

  1. import java.io.*;  
  2. class CopyPic {  
  3. public static void main(String[] args){  
  4. copyBmp();
  5. System.out.println("复制完成");
  6. }
  7. public static void copyBmp() {  
  8. FileInputStream fis = null;  
  9. FileOutputStream fos = null;  
  10. try {  
  11. fis = new FileInputStream("F:\\java_Demo\\day9_28\\1.bmp");             //写入流关联文件  
  12. fos = new FileOutputStream("F:\\java_Demo\\day9_28\\2.bmp");            //读取流关联文件  
  13. byte[] copy = new byte[1024];  
  14. int len = 0;  
  15. while((len=fis.read(copy))!=-1) {  
  16. fos.write(copy,0,len);
  17. }
  18. }
  19. catch (IOException e) {  
  20. e.printStackTrace();
  21. throw new RuntimeException("复制文件异常");  
  22. }
  23. finally {  
  24. try {  
  25. if(fis!=null) fis.close();  
  26. }
  27. catch (IOException e) {  
  28. e.printStackTrace();
  29. throw new RuntimeException("读取流");  
  30. }
  31. }
  32. }
  33. }

2. 字节流缓冲区

* 字节流缓冲区跟字符流缓冲区一样,也是为了提高效率。

注意事项:

1. read():会将字节byte()提升为int型值

2. write():会将int类型转换为byte()类型,保留最后的8位。

练习:

1.复制MP3文件   1.MP3 -->  2.MP3

2.自己写一个MyBufferedInputStream缓冲类,提升复制速度

  1. import java.io.*;  
  2. //自己的BufferedInputStream
  3. class MyBufferedInputStream  {  
  4. private InputStream in;                         //定义一个流对象  
  5. private byte [] buf = new byte[1024*4];  
  6. private int count = 0,pos = 0;  
  7. public MyBufferedInputStream(InputStream in){  
  8. this.in = in;  
  9. }
  10. public  int MyRead() throws IOException{  
  11. if(count==0) {              //当数组里的数据为空时候,读入数据  
  12. count = in.read(buf);
  13. pos = 0;
  14. byte b = buf[pos];  
  15. count--;
  16. pos++;
  17. return b&255;       //提升为int类型,在前面三个字节补充0。避免1111 1111 1111 1111  
  18. }
  19. else if(count > 0) {  
  20. byte b = buf[pos];  
  21. pos++;
  22. count--;
  23. return b&0xff;      //提升为int类型,在前面三个字节补充0。避免1111 1111 1111 1111  
  24. }
  25. return -1;  
  26. }
  27. public void myClose() throws IOException{  
  28. in.close();
  29. }
  30. }
  31. class BufferedCopyDemo {  
  32. public static void main(String[] args) {  
  33. long start = System.currentTimeMillis();  
  34. copy();
  35. long end = System.currentTimeMillis();  
  36. System.out.println("时间:"+(end-start)+"ms");
  37. start = System.currentTimeMillis();
  38. copy1();
  39. end = System.currentTimeMillis();
  40. System.out.println("时间:"+(end-start)+"ms");
  41. }
  42. public static void copy1() {                //    应用自己的缓冲区缓冲数据  
  43. MyBufferedInputStream bis = null;  
  44. BufferedOutputStream  bos = null;  
  45. try {  
  46. bis = new MyBufferedInputStream(new FileInputStream("马旭东-入戏太深.mp3"));//匿名类,传入一个InputStream流对象  
  47. bos = new BufferedOutputStream(new FileOutputStream("3.mp3"));  
  48. int buf = 0;  
  49. while((buf=bis.MyRead())!=-1) {  
  50. bos.write(buf);
  51. }
  52. }
  53. catch (IOException e) {  
  54. e.printStackTrace();
  55. throw new RuntimeException("复制失败");  
  56. }
  57. finally {  
  58. try {  
  59. if(bis!=null)  {  
  60. bis.myClose();
  61. bos.close();
  62. }
  63. }
  64. catch (IOException e) {  
  65. e.printStackTrace();
  66. }
  67. }
  68. }
  69. }

 

五、流操作规则

1. 键盘读取,控制台打印。

System.out: 对应的标准输出设备:控制台  //它是PrintStream对象,(PrintStream:打印流。OutputStream的子类)

System.in: 对应的标准输入设备:键盘     //它是InputStream对象

示例:

  1.  /*================从键盘录入流,打印到控制台上================*/
  2. public static void InOutDemo(){  
  3. //键盘的最常见的写法
  4. BufferedReader bufr = null;  
  5. BufferedWriter bufw = null;  
  6. try {  
  7. /*InputStream ips = System.in;        //从键盘读入输入字节流
  8. InputStreamReader fr = new InputStreamReader(ips);             //将字节流转成字符流
  9. bufr = new BufferedReader(fr);  */                 //将字符流加强,提升效率
  10. bufr = new BufferedReader(new InputStreamReader(System.in));            //匿名类。InputSteamReader:读取字节并将其解码为字符  
  11. bufw = new BufferedWriter(new OutputStreamWriter(System.out));      //OutputStreamWriter:要写入流中的字符编码成字节  
  12. String line = null;  
  13. while((line = bufr.readLine())!=null){  
  14. if("over".equals(line)) break;  
  15. bufw.write(line.toUpperCase());                     //打印
  16. bufw.newLine();                                     //为了兼容,使用newLine()写入换行符
  17. bufw.flush();                                       //必须要刷新。不然不会显示
  18. }
  19. if(bufw!=null) {  
  20. bufr.close();
  21. bufw.close();
  22. }
  23. }
  24. catch (IOException e) {  
  25. e.printStackTrace();
  26. }
  27. }
  28. }

2. 整行录入

1.从键盘录入数据,并存储到文件中。

2. 我们在键盘录入的是时候,read()方法是一个一个录入的,能不能整行的录入呢?这时候我们想到了BufferedReader中ReadLine()方法。

3. 转换流

为了让字节流可以使用字符流中的方法,我们需要转换流。

1. InputStreamReader:字节流转向字符流;

a、获取键盘录入对象。

InputStream in=System.in;

b、将字节流对象转成字符流对象,使用转换流。

InputStreamReaderisr=new InputStreamReader(in);

c、为了提高效率,将字符串进行缓冲区技术高效操作。使用BufferedReader

BufferedReaderbr=new BufferedReader(isr);

//键盘录入最常见写法

BufferedReaderin=new BufferedReader(new InputStreamReader(System.in));

2.OutputStreamWriter:字符流通向字节流

示例:

  1. /*================把键盘录入的数据存到一个文件中==============*/
  2. public static void inToFile() {  
  3. //键盘的最常见的写法
  4. BufferedReader bufr = null;  
  5. BufferedWriter bufw = null;  
  6. try {  
  7. /*InputStream ips = System.in;        //从键盘读入输入字节流
  8. InputStreamReader fr = new InputStreamReader(ips);             //将字节流转成字符流
  9. bufr = new BufferedReader(fr);  */                 //将字符流加强,提升效率
  10. bufr = new BufferedReader(new InputStreamReader(System.in));            //匿名类。InputSteamReader:读取字节并将其解码为字符  
  11. bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("out.txt")));     //OutputStreamWriter:要写入流中的字符编码成字节  
  12. String line = null;  
  13. while((line = bufr.readLine())!=null){  
  14. if("over".equals(line)) break;  
  15. bufw.write(line.toUpperCase());                     //打印
  16. bufw.newLine();                                     //为了兼容,使用newLine()写入换行符
  17. bufw.flush();                                       //必须要刷新。不然不会显示
  18. }
  19. if(bufw!=null) {  
  20. bufr.close();
  21. bufw.close();
  22. }
  23. }
  24. catch (IOException e) {  
  25. e.printStackTrace();
  26. }
  27. }

4. 流操作基本规律

为了控制格式我将其写入了Java代码段中,如下:

示例1:文本 ~ 文本

  1. /*
  2. 流操作的基本规律。
  3. 一、两个明确:(明确体系)
  4. 1. 明确源和目的
  5. 源:输入流  InputStream  Reader
  6. 目的:输出流  OutputStream Writer
  7. 2. 操作的数据是否是纯文本
  8. 是: 字符流
  9. 否: 字节流
  10. 二、明确体系后要明确具体使用的对象
  11. 通过设备区分:内存,硬盘,键盘
  12. 目的设备:内存,硬盘,控制台
  13. 示例1:将一个文本文件中的数据存储到另一个文件中: 复制文件
  14. 一、明确体系
  15. 源:文件-->读取流-->(InputStream和Reader)
  16. 是否是文本:是-->Reader
  17. 目的:文件-->写入流-->(OutputStream Writer)
  18. 是否纯文本:是-->Writer
  19. 二、 明确设备
  20. 源:Reader
  21. 设备:硬盘上一个文本文件 --> 子类对象为:FileReader
  22. FileReader fr = new FileReader("Goods.txt");  
  23. 是否提高效率:是-->加入Reader中的缓冲区:BufferedReader
  24. BufferedReader bufr = new BufferedReader(fr);  
  25. 目的:Writer
  26. 设备:键盘上一个文本文件 --> 子类对象:FileWriter
  27. FileWriter fw = new FileWriter("goods1.txt");  
  28. 是否提高效率:是-->加入Writer的缓冲区:BufferedWriter
  29. BufferedWriter bufw = new BufferedWriter(fw);  
  30. 示例2:将一个图片文件数据复制到另一个文件中:复制文件
  31. 一、明确体系
  32. 源:文件-->读取流-->(InputStream和Reader)
  33. 是否是文本:否-->InputStream
  34. 目的:文件-->写入流-->(OutputStream Writer)
  35. 是否纯文本:否-->OutputStream
  36. 二、 明确设备
  37. 源:InputStream
  38. 设备:硬盘上一个媒体文件 --> 子类对象为:FileInputStream
  39. FileInputStream fis = new FileInputStream("Goods.txt");  
  40. 是否提高效率:是-->加入InputStream中的缓冲区:BufferedInputStream
  41. BufferedInputStream bufi = new BufferedInputStream(fis);  
  42. 目的:OutputStream
  43. 设备:键盘上一个媒体文件 --> 子类对象:FileOutputStream
  44. FileOutputStream fos = new FileOutputStream("goods1.txt");  
  45. 是否提高效率:是-->加入OutputStream的缓冲区:BufferedOutputStream
  46. BufferedOutputStream bufo = new BufferedOutputStream(fw);  
  47. 示例3:将键盘录入的数据保存到一个文本文件中
  48. 一、明确体系
  49. 源:键盘-->读取流-->(InputStream和Reader)
  50. 是否是文本:是-->Reader
  51. 目的:文件-->写入流-->(OutputStream Writer)
  52. 是否纯文本:是-->Writer
  53. 二、 明确设备
  54. 源:InputStream
  55. 设备:键盘 --> 对用对象为:System.in --> InputStream
  56. 为了操作方便,转成字符流Reader --> 使用Reader中的转换流:InputStreamReader
  57. InputStreamReader isr = new InputStreamReader(System.in);  
  58. 是否提高效率:是-->加入Reader中的缓冲区:BufferedReader
  59. BufferedReader bufr = new BufferedReader(isr);  
  60. 目的:Writer
  61. 设备:键盘上一个文本文件 --> 子类对象:FileWriter
  62. FileWriter fw = new FileWriter("goods1.txt");  
  63. 是否提高效率:是-->加入Writer的缓冲区:BufferedWriter
  64. BufferedWriter bufw = new BufferedWriter(fw);  

5.指定编码表(转换流可以指定编码表)

要求:用UTF-8编码存储一个文本文件

[java] view plain copy

  1. import java.io.*;  
  2. public class IOStreamLaw {  
  3. /**
  4. * @param args
  5. */
  6. public static void main(String[] args) throws IOException {  
  7. //键盘的最常见写法
  8. BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
  9. BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("goods1.txt"),"UTF-8"));  
  10. String line = null;  
  11. while((line=bufr.readLine())!=null){  
  12. if("over".equals(line)) break;  
  13. bufw.write(line.toUpperCase());
  14. bufw.newLine();
  15. bufw.flush();
  16. }
  17. bufr.close();
  18. }
  19. }

 

 

 

分布式-网络通信-IO-基础(1)的更多相关文章

  1. 分布式强化学习基础概念(Distributional RL )

    分布式强化学习基础概念(Distributional RL) from: https://mtomassoli.github.io/2017/12/08/distributional_rl/ 1. Q ...

  2. java IO基础操作

    java IO基础,通熟易懂,好久没复习java 基础了.这里是传送门... http://www.cnblogs.com/nerxious/archive/2012/12/15/2818848.ht ...

  3. AWS EC2+Docker+JMeter构建分布式负载测试基础架构

    目录 概述及范围 前提条件 Part 1: Local setup-本地配置 Part 2: Cloud端基础架构--Infrastructure 总结: 原文链接 @ 概述及范围 本文介绍有关如何使 ...

  4. 归纳从文件中读取数据的六种方法-JAVA IO基础总结第2篇

    在上一篇文章中,我为大家介绍了<5种创建文件并写入文件数据的方法>,本节我们为大家来介绍6种从文件中读取数据的方法. 另外为了方便大家理解,我为这一篇文章录制了对应的视频:总结java从文 ...

  5. 总结java创建文件夹的4种方法及其优缺点-JAVA IO基础总结第三篇

    本文是Java IO总结系列篇的第3篇,前篇的访问地址如下: 总结java中创建并写文件的5种方式-JAVA IO基础总结第一篇 总结java从文件中读取数据的6种方法-JAVA IO基础总结第二篇 ...

  6. 总结删除文件或文件夹的7种方法-JAVA IO基础总结第4篇

    本文是Java IO总结系列篇的第4篇,前篇的访问地址如下: 总结java中创建并写文件的5种方式-JAVA IO基础总结第一篇 总结java从文件中读取数据的6种方法-JAVA IO基础总结第二篇 ...

  7. 总结java中文件拷贝剪切的5种方式-JAVA IO基础总结第五篇

    本文是Java IO总结系列篇的第5篇,前篇的访问地址如下: 总结java中创建并写文件的5种方式-JAVA IO基础总结第一篇 总结java从文件中读取数据的6种方法-JAVA IO基础总结第二篇 ...

  8. Day16_92_Java IO 基础概念

    Java IO 基础概念 流根据方向分为 输入流 和 输出流. 注意 : 输入和输出是相对与内存而言的,从内存出来就是输出,到内存中去就是输入. 输入叫做 "读" , 输出叫做 & ...

  9. Album++:分布式事务专辑-基础概念

    (一)基础概念:↓ ↓ ↓ 1.1)什么是事务 什么是事务?举个生活中的例子:你去小卖铺买东西,"一手交钱,一手交货"就是一个事务的例子,交钱和交货必 须全部成功, 事务才算成功, ...

  10. [源码解析] PyTorch 分布式(4)------分布式应用基础概念

    [源码解析] PyTorch 分布式(4)------分布式应用基础概念 目录 [源码解析] PyTorch 分布式(4)------分布式应用基础概念 0x00 摘要 0x01 基本概念 0x02 ...

随机推荐

  1. 通过PlayBook部署Zabbix

    编写Linux初始化剧本 初始化剧本环节,主要用户实现关闭Selinux关闭防火墙,一起配置一下阿里云的YUM源地址,和安装EPEL源,为后期的zabbix安装做好铺垫工作. 1.在安装Zabbix之 ...

  2. ELK电子书籍

    Elasticsearch in Action(英文版).pdfElasticsearch实战 in action(中文版).pdfElasticsearch技术解析与实战.pdfElasticsea ...

  3. nginx相关知识点

    1.nginx -V 可以查看nginx的安装目录等目录信息 2.nginx -v 查看版本 3.路径 /usr/local/etc/nginx/nginx.conf (配置文件路径) /usr/lo ...

  4. mysql中有条件的插入语句

    今天在参加笔试的过程中,看到一道题,大概意思就是说,当满足了条件就执行插入语句,当时就蒙了,之前从来都没有考虑过满足条件才插入的情况,所以一直都是这样写的 insert into table_name ...

  5. 重学HTML5的语义化

    干了这么多年的前端,之前面试的时候经常会遇到面试官提问:你是如何理解HTML的语义化的? 说实话,之前遇到这个问题的时候,都是从网上找参考答案,然后记下来,用自己的语言重新组织一下,就变成自己的理解了 ...

  6. 用js方式取得接口里面json数据的key和value值

    大家在实际操作中难免遇到对接口的问题,想必对一些小白来说取得里面想要是数据也是很是头疼,那么接下来我会结合接口实际情况教大家怎么取得里面相应的数据 接口数据例如:(数据为 模拟数据,json格式) { ...

  7. Spring框架中<mvc:default-servlet-handler/>的作用

    优雅REST风格的资源URL不希望带 .html 或 .do 等后缀.由于早期的Spring MVC不能很好地处理静态资源,所以在web.xml中配置DispatcherServlet的请求映射,往往 ...

  8. 依赖注入 php

    依赖注入:将当前类依赖的对象,以参数的方式注入到当前类中,简称依赖注入 <?php class Mi { public function size() { return '5.99寸全面屏'; ...

  9. 三种Shell脚本编程中避免SFTP输入密码的方法

    最近编程中用到sftp上传文件,且需要用crontab预设定时上传事件.而sftp不同于ftp,没有提供选项如 -i 可以将密码直接编码进程序.使用sftp指令,会自动请求用户输入密码. 总结一下可以 ...

  10. SQL SERVER 查询被锁的表、解锁表

    -- 查询被锁的表select   request_session_id   spid,OBJECT_NAME(resource_associated_entity_id) tableName   f ...