javaEE - 6（11000 详解文件操作）

已于 2025-03-02 12:16:12 修改
阅读量1.7k 收藏 9
点赞数 11
分类专栏： javaEE 文章标签： java-ee java
于 2023-10-23 22:46:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73232539/article/details/133997148
版权

一：认识文件

针对硬盘这种持久化存储的 I / O 设备，当我们想要进行数据保存时，往往不是保存成一个整体，而是独立成一个个的单位进行保存，这个独立的单位就被抽象成文件的概念，就类似办公桌上的一份份真实的文件一般。

文件除了有数据内容之外，还有一部分信息，例如文件名、文件类型、文件大小等并不作为文件的数据而存在，我们把这部分信息可以视为文件的元信息。

在这里插入图片描述
同时，随着文件越来越多，我们就需要对文件进行管理，如何进行文件的组织呢，一种合乎自然的想法出现了，就是按照层级结构进行组织 —— 也就是我们数据结构中学习过的树形结构。这样，一种专门用来存放管理信息的特殊文件诞生了，也就是我们平时所谓文件夹或者目录的概念。

在这里插入图片描述
在这里插入图片描述

1.1 文件路径

如何在文件系统中如何定位我们的一个唯一的文件就成为当前要解决的问题，这其实很简单，因为从树型结构的角度来看，树中的每个结点都可以被一条从根开始，一直到达的结点的路径所描述，而这种描述方式就被称为文件的绝对路径。
在这里插入图片描述
除了可以从根开始进行路径的描述，我们还可以从任意结点出发进行路径的描述，而这种描述方式就被称为相对路径，相对于当前所在结点的一条路径。

在这里插入图片描述
文件的相对路径是以工作目录为基准的，每个程序运行的时候都有一个工作目录，IDEA 的工作目录默认为当前项目所在的目录

1.2 文件的分类

文件根据其保存数据的不同，被分为不同的类型，我们一般简单的划分为文本文件和二进制文件，分别指代保存被字符集编码的文本和按照标准格式保存的非被字符集编码过的文件。
在这里插入图片描述

1.3 文件管理

Windows 操作系统上，会按照文件名中的后缀来确定文件类型以及该类型文件的默认打开程序。但这个习俗并不是通用的，在 OSX、Unix、Linux 等操作系统上，就没有这样的习惯，一般不对文件类型做如此精确地分类。
在这里插入图片描述
文件由于被操作系统进行了管理，所以根据不同的用户，会赋予用户不同的对待该文件的权限，一般地可以认为有可读、可写、可执行权限。
在这里插入图片描述
Windows 操作系统上，还有一类文件比较特殊，就是平时我们看到的快捷方式，这种文件只是对真实文件的一种引用而已。其他操作系统上也有类似的概念，例如软链接等。
在这里插入图片描述
最后，很多操作系统为了实现接口的统一性，将所有的 I / O 设备都抽象成了文件的概念，使用这一理念最为知名的就是 Unix、Linux 操作系统 —— 万物皆文件。

二： Java 中操作文件

Java 中通过 java.io.File 类来对一个文件进行抽象的描述。注意，有 File 对象，并不代表真实存在该文件，下面我们来看看 File 类中的常见属性、构造方法和方法：

  1. 属性
修饰符及类型属性说明
staticStringpathSeparator （ 路径分隔字符串 ）
staticcharpathSeparatorChar （ 路径分隔字符 ）
  1. 构造方法
方法签名说明
File(File parent, String child)根据父目录 + 孩子文件路径，创建一个新的 File 实例
File(String pathname)根据文件路径创建一个新的 File 实例，路径可以是绝对路径或者相对路径
File(String parent, String child)根据父目录 + 孩子文件路径，创建一个新的 File 实例，父目录用路径表示
import java.io.File;

public class FileConstructorExample {
    public static void main(String[] args) {
        // 使用父目录 + 孩子文件路径创建一个新的 File 实例
        File file1 = new File("C:/myfolder", "myfile.txt"); // C:/myfolder/myfile.txt

        // 使用文件路径创建一个新的 File 实例
        File file2 = new File("C:/myfolder/myfile.txt"); // C:/myfolder/myfile.txt

        // 使用父目录 + 孩子文件路径创建一个新的 File 实例，父目录用路径表示
        File parentDir = new File("C:/myfolder");
        File file3 = new File(parentDir, "myfile.txt"); // C:/myfolder/myfile.txt

        System.out.println("file1 路径：" + file1.getPath());
        System.out.println("file2 路径：" + file2.getPath());
        System.out.println("file3 路径：" + file3.getPath());
    }
}
  1. 常用方法：
修饰符及返回值类型方法签名说明
StringgetParent()返回 File 对象的父目录文件路径
StringgetName()返回 File 对象的纯文件名称
StringgetPath()返回 File 对象的文件路径
StringgetAbsolutePath()返回 File 对象的绝对路径
StringgetCanonicalPath()返回 File 对象的修饰过的绝对路径
booleanexists()判断 File 对象描述的文件是否真实存在
booleanisDirectory()判断 File 对象代表的文件是否是一个目录
booleanisFile()判断 File 对象代表的文件是否是一个普通文件
booleancreateNewFile()根据 File 对象，自动创建一个空文件。成功创建后返回 true
booleandelete()根据 File 对象，删除该文件。成功删除后返回 true
voiddeleteOnExit()根据 File 对象，标注文件将被删除，删除动作会到 JVM 运行结束时才会进行
String[]list()返回 File 对象代表的目录下的所有文件名
File[]listFiles()返回 File 对象代表的目录下的所有文件，以 File 对象表示
booleanmkdir()创建 File 对象代表的目录
booleanmkdirs()创建 File 对象代表的目录，如果必要，会创建中间目录
booleanrenameTo(File dest)进行文件改名，也可以视为我们平时的剪切、粘贴操作
booleancanRead()判断用户是否对文件有可读权限
booleancanWrite()判断用户是否对文件有可写权限

以下是这些方法的使用示例代码：

import java.io.File;
import java.io.IOException;

public class FileExample {
    public static void main(String[] args) {
        // 创建 File 对象
        File file = new File("C:/Users/86198/Desktop/test/test1.txt");

        // 输出文件的父目录路径
        System.out.println("父目录路径: " + file.getParent()); // 父目录路径: C:/Users/86198/Desktop/test

        // 输出文件的名称
        System.out.println("文件名称: " + file.getName()); // 文件名称: test1.txt

        // 输出文件的路径
        System.out.println("文件路径: " + file.getPath()); // 文件路径: C:/Users/86198/Desktop/test/test1.txt

        // 输出文件的绝对路径
        System.out.println("绝对路径: " + file.getAbsolutePath()); // 绝对路径: C:/Users/86198/Desktop/test/test1.txt

        // 输出文件的修饰绝对路径
        try {
            System.out.println("规范路径: " + file.getCanonicalPath()); // 规范路径: C:/Users/86198/Desktop/test/test1.txt
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 判断文件是否存在
        System.out.println("文件是否存在: " + file.exists()); // 文件是否存在: true

        // 判断是否是目录
        System.out.println("是否是目录: " + file.isDirectory()); // 是否是目录: false

        // 判断是否是普通文件
        System.out.println("是否是普通文件: " + file.isFile()); // 是否是普通文件: true

        // 判断是否可读
        System.out.println("是否可读: " + file.canRead()); // 是否可读: true

        // 判断是否可写
        System.out.println("是否可写: " + file.canWrite()); // 是否可写: true

        // 创建一个新文件
        File newFile = new File("C:/Users/86198/Desktop/test/newFile.txt");
        try {
            if (newFile.createNewFile()) {
                System.out.println("新文件已创建: " + newFile.getPath()); // 新文件已创建: C:/Users/86198/Desktop/test/newFile.txt
            } else {
                System.out.println("新文件创建失败，文件已存在: " + newFile.getPath()); // 新文件创建失败，文件已存在: C:/Users/86198/Desktop/test/newFile.txt
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 删除文件
        if (newFile.delete()) {
            System.out.println("新文件已删除: " + newFile.getPath()); // 新文件已删除: C:/Users/86198/Desktop/test/newFile.txt
        } else {
            System.out.println("新文件删除失败: " + newFile.getPath()); // 新文件删除失败: C:/Users/86198/Desktop/test/newFile.txt
        }

        // 列出当前目录下的所有文件名
        File dir = new File("C:/Users/86198/Desktop/test");
        if (dir.isDirectory()) {
            System.out.println("目录中的文件名列表: "); // 目录中的文件名列表:
            String[] fileList = dir.list();
            if (fileList != null) {
                for (String fileName : fileList) {
                    System.out.println(fileName); // test1.txt, test2.txt 等
                }
            }
        }

        // 列出当前目录下的所有文件对象
        System.out.println("目录中的文件对象列表: "); // 目录中的文件对象列表:
        File[] fileArray = dir.listFiles();
        if (fileArray != null) {
            for (File f : fileArray) {
                System.out.println(f.getPath()); // C:/Users/86198/Desktop/test/test1.txt 等
            }
        }

        // 创建一个目录
        File newDir = new File("C:/Users/86198/Desktop/test/newDir");
        if (newDir.mkdir()) {
            System.out.println("目录已创建: " + newDir.getPath()); // 目录已创建: C:/Users/86198/Desktop/test/newDir
        } else {
            System.out.println("目录创建失败: " + newDir.getPath()); // 目录创建失败: C:/Users/86198/Desktop/test/newDir
        }

        // 删除新建的目录
        if (newDir.delete()) {
            System.out.println("目录已删除: " + newDir.getPath()); // 目录已删除: C:/Users/86198/Desktop/test/newDir
        } else {
            System.out.println("目录删除失败: " + newDir.getPath()); // 目录删除失败: C:/Users/86198/Desktop/test/newDir
        }

        // 进行文件重命名（剪切/粘贴操作）
        File renameFile = new File("C:/Users/86198/Desktop/test/test2.txt");
        if (file.renameTo(renameFile)) {
            System.out.println("文件已重命名为: " + renameFile.getPath()); // 文件已重命名为: C:/Users/86198/Desktop/test/test2.txt
        } else {
            System.out.println("文件重命名失败"); // 文件重命名失败
        }
    }
}

三：文件内容的读写——数据流

在这里插入图片描述

对于流的分类我们有两种分法：

  1. 按流的方向分类：输入流、输出流
  2. 按数据处理单位：字节流、字符流

现在我们理解一下什么是输入，什么是输出，什么是字节流，什么是字符流：

类别描述
字节流以字节（8 位）为单位处理数据，适合处理二进制文件，如图片、音频、视频等。
字符流以字符（16 位）为单位处理数据，适合处理文本文件，如 .txt 文件等。
输入程序从外部数据源（如文件、键盘、网络等）读取数据到程序内部的过程称为输入。
输出程序将数据从内部写入到外部数据目标（如文件、屏幕、网络等）的过程称为输出。

在这里插入图片描述

3.1 字节输入流（ InputStream ）

InputStream 是 Java 中用于读取字节数据的抽象类，常用的子类包括 FileInputStream。它主要用于读取二进制数据，但也可以读取文本文件，FileInputStream 常用方法如下：

方法描述
int read()读取单个字节，返回值为 0 - 255 的字节值。如果返回 -1，表示读取到文件末尾。
int read(byte[] b)读取多个字节，存储到字节数组 b 中，返回实际读取的字节数。如果返回 -1，表示文件结束。
int read(byte[] b, int off, int len)该方法从字符输入流中最多读取 len 个字节，并将它们存储到字符数组 b 中，从数组的 off 位置开始存储。
void close()关闭输入流，释放资源。

文件的内容如图所示：
在这里插入图片描述

public class InputStreamExample {
    public static void main(String[] args) {
        String filePath = "C:/Users/86198/Desktop/演示文件.txt";

        try (FileInputStream inputStream = new FileInputStream(filePath)) {
            // 1. 使用 read() 读取单个字节
            System.out.println("使用 read() 读取单个字节:");
            int data;
            while ((data = inputStream.read()) != -1) {
                System.out.print((char) data); // 输出字节对应的字符
                //输出 abcdefg1234567
            }
            System.out.println();  // 换行

            // 2. 使用 read(byte[] b) 读取多个字节
            byte[] buffer = new byte[8]; // 创建 8 字节大小的数组
            try (FileInputStream inputStream2 = new FileInputStream(filePath)) {
                System.out.println("使用 read(byte[] b) 读取多个字节:");
                int bytesRead = inputStream2.read(buffer);  // 读取最多 8 个字节
                for (int i = 0; i < bytesRead; i++) {
                    System.out.print((char) buffer[i]);  // 输出字节对应的字符
                    //输出 abcdefg1
                }
                System.out.println();
            }

            // 3. 使用 read(byte[] b, int off, int len) 从偏移量开始读取
            byte[] buffer2 = new byte[8]; // 再创建一个 8 字节大小的数组
            try (FileInputStream inputStream3 = new FileInputStream(filePath)) {
                System.out.println("使用 read(byte[] b, int off, int len) 从偏移量开始读取:");
                int bytesRead = inputStream3.read(buffer2, 2, 6);  // 从 buffer2 数组的索引为 2 （从 0 开始）的地方开始存储读取到的数据，最多读取 6 个字节。
                for (int i = 2; i < 2 + bytesRead; i++) {
                    System.out.print((char) buffer2[i]);  // 输出字节对应的字符
                    //输出 abcdef
                }
                System.out.println();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

可以这样理解，字符流和字节流都是读取或修改文件中的内容，但是字节流是按照一个字节一个字节的方式读的，而字符流是按照两个字节两个字节的方式读的。这里可能有一个误区，Java 的字符不是 2 字节的吗，为什么我们可以读取一个字节赋值给他，注意，这和 Java 的 Unicode 编码没有什么太大关系，你只需要知道字节流每次读取一个字节就可以了，当字节流遇到中文就可能出现乱码。

3.2 字节输出流（ OutputStream ）

OutputStream 是 Java 中用于写入字节数据的抽象类，常用的子类包括 FileOutputStream。它主要用于写入二进制数据，也可以写入文本文件，FileOutputStream 的常用方法如下：

方法描述
void write(int b)写入一个字节。
void write(byte[] b)写入字节数组 b 中的所有字节。
void write(byte[] b, int off, int len)从字节数组 b 的 off 位置开始，写入 len 个字节。
void close()关闭输出流，释放资源。
public class OutputStreamExample {
    public static void main(String[] args) {
        String filePath = "C:/Users/86198/Desktop/演示文件.txt";
        
        // 1. 使用 write(int b) 写入单个字节
        try (FileOutputStream outputStream = new FileOutputStream(filePath)) {
            System.out.println("使用 write(int b) 写入单个字节:");
            outputStream.write('A');  // 写入单个字符 'A'
            System.out.println("写入 A 成功");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 2. 使用 write(byte[] b) 写入字节数组
        String content = "Hello123";
        byte[] contentBytes = content.getBytes();  // 将字符串转换为字节数组
        try (FileOutputStream outputStream = new FileOutputStream(filePath, true)) {  // true 为追加模式，false 为覆盖模式
            System.out.println("使用 write(byte[] b) 写入字节数组:");
            outputStream.write(contentBytes);  // 写入字节数组
            System.out.println("写入 Hello123 成功");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 3. 使用 write(byte[] b, int off, int len) 写入部分字节数组
        try (FileOutputStream outputStream = new FileOutputStream(filePath, true)) {  // true 为追加模式，false 为覆盖模式
            System.out.println("使用 write(byte[] b, int off, int len) 写入部分字节数组:");
            outputStream.write(contentBytes, 0, 5);  // 从字节数组 contentBytes 的 0  位置开始，写入 5 个字节。
            System.out.println("写入 Hello 成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

在这里插入图片描述

3.3 字符输入流（ Reader ）

Reader 是 Java 中用于读取字符数据的抽象类，常用的子类有 FileReader。它主要用于读取文本文件，FileReader 的常用方法如下：

方法描述
int read()读取单个字符，返回值为字符的 Unicode 值。如果返回 -1，表示文件结束。
int read(char[] cbuf)将字符读入到字符数组 cbuf 中，返回实际读取的字符数。
int read(char[] cbuf, int off, int len)该方法从字符输入流中最多读取 len 个字符，并将它们存储到字符数组 cbuf 中，从数组的 off 位置开始存储。
void close()关闭输入流，释放资源。

文件的内容如图所示：

在这里插入图片描述

public class ReaderExample {
    public static void main(String[] args) {
        String filePath = "C:/Users/86198/Desktop/演示文件.txt";

        // 1. 使用 read() 读取单个字符
        try (FileReader reader = new FileReader(filePath)) {
            System.out.println("使用 read() 读取单个字符:");
            int data;
            while ((data = reader.read()) != -1) {
                System.out.print((char) data);  // 输出字符
                //输出abcdefg1234567
            }
            System.out.println();
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 2. 使用 read(char[] cbuf) 读取多个字符
        char[] buffer = new char[8];  // 创建字符数组
        try (FileReader reader = new FileReader(filePath)) {
            System.out.println("使用 read(char[] cbuf) 读取多个字符:");
            int charsRead = reader.read(buffer);  // 读取最多 8 个字符
            System.out.println(new String(buffer, 0, charsRead));  // 输出读取的字符
            //输出abcdefg1
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 3. 使用 read(char[] cbuf, int off, int len) 从偏移量开始读取
        char[] buffer2 = new char[8];
        try (FileReader reader = new FileReader(filePath)) {
            System.out.println("使用 read(char[] cbuf, int off, int len) 从偏移量开始读取:");
            int charsRead = reader.read(buffer2, 2, 6);  // 从 buffer2 数组偏移量为 2 开始读入 6 个字符
            for (int i = 2; i < 2 + charsRead; i++) {//第一第二个字符的0，所以要跳过
                System.out.print(buffer2[i]);  // 输出字符
                //输出abcdef
            }
            System.out.println();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.4 字符输出流（ Writer ）

Writer 是 Java 中用于写入字符数据的抽象类，常用的子类有 FileWriter，FileWriter 的常用方法如下：

方法描述
void write(int c)写入单个字符。
void write(char[] cbuf)将字符数组 cbuf 中的字符写入输出流。
void write(char[] cbuf, int off, int len)将字符数组 cbuf 中从偏移量 off 开始的 len 个字符写入输出流。
void close()关闭输出流，释放资源。
public class WriterExample {
    public static void main(String[] args) {
        String filePath = "C:/Users/86198/Desktop/演示文件.txt";
        String content = "Hello World";

        // 1. 使用 write(int c) 写入单个字符
        try (FileWriter writer = new FileWriter(filePath)) {
            System.out.println("使用 write(int c) 写入单个字符:");
            writer.write('A');  // 写入字符 'A'
            System.out.println("写入 A 成功");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 2. 使用 write(char[] cbuf) 写入字符数组
        try (FileWriter writer = new FileWriter(filePath, true)) {  // true 为追加模式，false 为覆盖模式
            System.out.println("使用 write(char[] cbuf) 写入字符数组:");
            writer.write(content.toCharArray());  // 写入字符数组
            System.out.println("写入 Hello World 成功");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 3. 使用 write(char[] cbuf, int off, int len) 写入部分字符数组
        try (FileWriter writer = new FileWriter(filePath, true)) {   // true 为追加模式，false 为覆盖模式
            System.out.println("使用 write(char[] cbuf, int off, int len) 写入部分字符数组:");
            writer.write(content.toCharArray(), 0, 5);  // 写入 "Hello"
            System.out.println("写入 Hello 成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

在这里插入图片描述

JAVA EE 6 jar包集合
12-18
java ee 开发中用到的jar包集合，版本为 javaee6 下载可以直接使用
JavaEE6
weixin_44355915的博客
08-13 1598
JavaEE： web：域前端交互，servlet+jsp+javaBean service：业务处理 dao：操作数据库，jdbc dbutils Filter：过滤器 过滤、拦截请求 url-pattern中的地址 实现过滤器步骤： 1.自定义类实现Filter方法 2.着重实现doFilter方法 3.注册-草看servlet 过滤器中可以有响应内容，也可以不放行 放行后的...
Java EE 6 草案提交, 新特性一览
香蕉熊的专栏
04-19 827
本月初, Bill Shannon 已经向JCP提交了Java EE 6 草案.      这也是JCP第一次揭示Java EE的概念，由于先前有JSRs，JSR 313 将不在定义新的API，但是将调整许多sub-JSRs 的工作来为Java EE 6平台提供一致性。　　JCP的站点提供了一些关于Java EE 6的发展趋势：　　扩展性　　对Java EE平台来说没有限制的增长包括对web和企业
javaee6 jar
07-20
创建javaee6项目所需的jar包，用于在myeclipse10一下版本构建javaee6项目
JavaEE-人事管理系统
04-04
《JavaEE-人事管理系统详解》 JavaEE-人事管理系统是一个基于JavaEE技术栈的企业级应用，主要用于实现人力资源的高效管理。这个系统包含了多个关键模块，包括用户管理、部门管理、职位管理、员工管理、公告管理和...
JAVAEE-期末卷-选择填空-已整理.doc
最新发布
06-27
- 发布到服务器上的组件除了自身的代码文件之外，还需要包含一个XML部署描述文件。这个文件用于描述组件的基本配置信息，比如组件依赖、环境设置等，对于服务器理解和正确部署组件至关重要。 2. **Java EE 技术...
精选_毕业设计_基于Android-JavaEE-DB2实现的旧物交易平台_完整源码
03-05
《基于Android-JavaEE-DB2的旧物交易平台开发详解》 在当今信息化社会，旧物交易平台已经成为一种高效、环保的资源再利用方式。本文将深入探讨一个基于Android客户端、JavaEE服务器端以及DB2数据库实现的旧物交易...
javaEE-个人网上博客
03-25
【JavaEE个人网上博客项目详解】 JavaEE，全称Java Platform, Enterprise Edition，是Java平台的企业版，主要用于构建企业级的分布式、多层架构的应用程序。在这个“JavaEE-个人网上博客”项目中，我们可以看到...
基于JavaEE-SSH-MVC实现的动漫论坛系统详解
6. 文件列表说明：压缩包中可能包含以下内容： - 源码：包含所有的Java源代码文件，是实现动漫论坛功能的程序代码。 - 数据库SQL脚本：包含创建数据库、表结构和初始化数据的SQL语句。 - 论文：文档形式的项目...
Java EE 6 标准与规范(中文版)
11-26
Java 企业级6.0版本的中文规范,希望对你有所帮助,文档内容涵盖了JavaEE的方方面面.
javaee6开发包
09-25
myeclipse9一下的版本并没有集成javaee6的开发包，用户需要另外下载才能使用，很多人不愿意安装臃肿的myeclipse10，现在将myeclipse10中默认包含的javaee6的开发包打包发布，只要解压将里面的jar包导入到项目（或者直接扔到lib文件夹）就可以使用了，这是开发j2ee的必备开发包
javaEE6jar包
09-17
javaEE6jar包
javaee6.jar javaee6 jar包
03-07
javaee6 jar包
JavaEE6规范中文版(CHM)
06-28
JavaEE6规范中文版，附带英文对照 如果发现问题，请发邮件到yylfan@yahoo.com.cn
Java EE 6简介
JLife 雅致 博大 精深
01-26 1432
Java EE 6中最惹人注意的就是上下文和依赖注入规范(Context and Dependency Injection, CDI)-JSR299。 其中最重要的概念是Managed Bean。没错，就是这个称谓。有的开发者可能会问：先前JSF规范中不就有Managed Bean么？Java EE 6中的Managed Bean和JSF1.0中Managed Bean有本质区别。JSF1.0为...
JAVA EE 6 规范综述
飞鹰中间件技术讨论专栏
11-06 2287
1.JAVA EE规范综述 JAVA EE是作为JAVA语言的企业级规范进行指定的，其目的是满足于行业软件的企业的应用的需求，在复杂的业务逻辑的前提下，尽可能将屏蔽网络，硬件等复杂的设施，将这些内容转嫁给一些实现了部分JAVA EE规范服务的供应商或者完全实现JAVA EE规范的应用服务器厂商和来做，让系统集成商只关注与业务。 JAVA EE部分规范服务的提供商，以开源项目居多，以实用比较广泛
JSR规范系列（3）——JavaEE 6规范及其实现框架
ni_hao_fan的博客
11-27 953
Java EE 6 2.主要是servlet技术： 3.SOA web服务、RESTful web服务： 4.包括bean validator技术： 5.Spring框架： 6.JPA(类似于MyBatis的ORM框架)、Criteria API (类似于MyBatis Generator 框架) 7.安全 8.事务、数据源、连接池技术： ...
java ee6教程_Java EE 极简教程（六）：框架的选择
weixin_33921444的博客
02-23 320
瞅了一眼，距离上次写这个系列的文章已经两个半月了。其实早就想写了，但迟迟没有动手，不是不想，是担心写不好。因为要讲概念性的东西，搞不好就会误人子弟，所以不但要靠知识储备、要靠灵感，还要找到最佳的写作状态。我很佩服那些两三天甚至是每天都能出篇文章的博主，每次我憋出一篇文章都至少要三四个小时，也就周末有这个时间啦。虽说我只是一个不知名的技术博主，一个平平无奇的程序猿，但离奇地获得了一些读者的支持。虽然...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ice___Cpu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值