day10-配置文件&日志&多线程

于 2024-09-10 21:15:16 发布
阅读量1.1k 收藏 13
点赞数 36
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58478983/article/details/142108515
版权

一、配置文件

1.1 properties配置文件

properties配置文件
特点:
 1、都只能是键值对
 2、键不能重复
 3、文件后缀一般是.properties结尾的
​
Properties
 这是一个Map集合（键值对集合），但是我们一般不会当集合使用
 主要用来代表属性文件，通过Properties可以读写属性文件里的内容
构造器说明
public Properties()用于构建Properties集合对象（空容器）

使用Properties读取属性文件里的键值对数据

读取：磁盘---->内存

常用方法说明
public void load(InputStream is)通过字节输入流，读取属性文件里的键值对数据
public void load(Reader reader)通过字符输入流，读取属性文件里的键值对数据
public String getProperty(String key)根据键获取值(其实就是get方法的效果)
public Set<String> stringPropertyNames()获取全部键的集合（其实就是ketSet方法的效果）
public static void main(String[] args) throws IOException {
        //1. 创建一个配置文件对象
        Properties properties = new Properties();
        //2. 读取
        properties.load(new FileInputStream("day10-code\\xml\\user.properties"));
//        String value = properties.getProperty("admin");
//        System.out.println("admin = " + value);
//        String lisi = properties.getProperty("lisi","000000");
//        System.out.println("lisi = " + lisi);
        Set<String> keySet = properties.stringPropertyNames();
        for (String key : keySet) {
            String value = properties.getProperty(key);
            System.out.println(key + " = " + value);
        }
​
}

使用Properties把键值对数据写出到属性文件里去

写入：内存---->磁盘

常用方法说明
public Object setProperty(String key, String value)保存键值对数据到Properties对象中去。
public void store(OutputStream os, String comments)把键值对数据，通过字节输出流写出到属性文件里去
public void store(Writer w, String comments)把键值对数据，通过字符输出流写出到属性文件里去
public static void main(String[] args) throws IOException {
        // 写出
        Properties pro2 = new Properties();
        pro2.setProperty("zhu", "猪小贱");
        pro2.setProperty("lin","哼哼猪");
        pro2.setProperty("pang","羊习习");
        pro2.store(new FileOutputStream("day10-code\\xml\\user2.properties"),null);
}

总结

Properties的作用？具体如何使用？

1.可以加载属性文件中的数据到Properties对象中来

void load(Reader reader)

public String getProperty(String key) 根据键获取值

2.可以存储Properties属性集的键值对数据到属性文件中去

void store(Writer writer, String comments) 设置键值

public Object setProperty(String key, String value)

1.2 XML配置文件

XML
 全称 Extensible Markup Language， 可扩展标记语言
 本质是一种数据的格式，可以用来存储复杂的数据结构，和数据关系。
​
特点
 XML中的“<标签名>” 称为一个标签或一个元素，一般是成对出现的。
 XML中的标签名可以自己定义（可扩展），但必须要正确的嵌套。
 XML中只能有一个根标签。
 XML中的标签可以有属性。
 如果一个文件中放置的是XML格式的数据，这个文件就是XML文件，后缀一般要写成.xml。
​
语法
 XML文件的后缀名为：xml，文档声明必须是第一行
 XML中可以定义注释信息：<!–- 注释内容 -->，快捷键是Ctrl+shift+/
 XML中书写”<”、“&”等，可能会出现冲突，导致报错，此时可以用如下特殊字符替代。
 XML中可以写一个叫CDATA的数据区: <![CDATA[   …内容…  ]]>，里面的内容可以随便写。
​
XML的作用和应用场景
    作用：1）作为软件的配置文件   2）用于进行存储数据和传输数据
 经常用来做为系统的配置文件
 或者作为一种特殊的数据结构，在网络中进行传输。

 

 

1.2.1 Dom4j解析XML得到Document对象

SAXReader：Dom4j提供的解析器，可以认为是代表整个Dom4j框架

构造器/方法说明
public SAXReader()构建Dom4J的解析器对象
public Document read(String path)把XML文件读成Document对象

Document

方法名说明
Element getRootElement()获得根元素对象

Element提供的方法

方法名说明
public String getName()得到元素名字
public List<Element> elements()得到当前元素下所有子元素
public List<Element> elements(String name)得到当前元素下指定名字的子元素返回集合
public Element element(String name)得到当前元素下指定名字的子元素,如果有很多名字相同的返回第一个
public String attributeValue(String name)通过属性名直接得到属性值
public String elementText(子元素名)得到指定名称的子元素的文本
public String getText()得到文本
XML解析案例

需求：

利用Dom4J框架，将contacts.xml文件中的联系人数据，解析出来，封装成List集合，并遍历输出。

 

public class Demo2 {
    public static void main(String[] args) throws FileNotFoundException, DocumentException {
        List<User> userList = new ArrayList();
        //2.创建DOM4]解析器对象SAXReader，获取Document文档对象，获取根标签对象
        SAXReader saxReader = new SAXReader();
        //读取XML文件，读取到内存
        Document document = saxReader.read(new FileReader("day10-code/user.xml"));
        //3.从根标签对象开始往下层层解析
        //3.1 获取根标签的名字
        Element rootElement = document.getRootElement();
        String name = rootElement.getName();
        System.out.println("根标签的名字:" + name);
        //3.2 获取根标签下的所有子标签
        List<Element> elements = rootElement.elements();
        System.out.println("根标签下的所有子标签个数:" + elements.size());
        //3.3 遍历标签的集合
        for (Element element : elements) {
            System.out.println("==========================");
            String id = element.attributeValue("id");
            String elementName = element.getName();
            System.out.println("子标签的名字:" + elementName + "-" + id);
            String userName = element.element("name").getText();
            System.out.println("子标签下的name标签的文本:name=" + userName);
            String userPassword = element.element("password").getText();
            System.out.println("子标签下的password标签的文本:password=" + userPassword);
            String userAddress = element.element("address").getText();
            System.out.println("子标签下的address标签的文本:address=" + userAddress);
            String userGender = element.element("gender").getText();
            System.out.println("子标签下的gender标签的文本:gender=" + userGender);
            //3.4 封装对象到一个List<User对象的集合>
            userList.add(new User(userName, userGender, userAddress, userPassword));
        }
        System.out.println("==========================");
        System.out.println(userList);
​
​
​
    }
}
class User{
    private String name;
    private String gender;
    private String address;
    private String password;
​
    public User() {
    }
​
    public User(String name, String gender, String address, String password) {
        this.name = name;
        this.gender = gender;
        this.address = address;
        this.password = password;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public String getGender() {
        return gender;
    }
​
    public void setGender(String gender) {
        this.gender = gender;
    }
​
    public String getAddress() {
        return address;
    }
​
    public void setAddress(String address) {
        this.address = address;
    }
​
    public String getPassword() {
        return password;
    }
​
    public void setPassword(String password) {
        this.password = password;
    }
​
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", address='" + address + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

二、日志

1、什么是日志？

用来记录程序运行过程中的信息，并可以进行永久存储。

2、常见的日志实现框架有哪些？

Log4J、Logback(我们重点学习的，其他的都大同小异)

Logback是基于slf4j日志接口实现的日志框架

3、使用Logback至少需要使用哪几个模块？

slf4j-api：日志接口

logback-core：基础模块

logback-classic：功能模块，它完整实现了slf4j API

2.1 Logback

需求
    使用Logback日志框架，纪录系统的运行信息。
实现步骤
    1. 导入Logback框架到项目中去。
    2. 将Logback框架的核心配置文件logback.xml直接拷贝到src目录下（必须是src下）。
    4. 创建Logback框架提供的Logger对象，然后用Logger对象调用其提供的方法就可以记录系统的日志信息。
        public static final Logger LOGGER = LoggerFactory.getLogger("当前类类名");
    5. 打印日志
        LOGGER.info("日志信息")//给重要的信息打日志
        LOGGER.debug("日志信息")//给调试信息打日志
        LOGGER.error("日志信息")//try-catch中给错误信息打日志
public class Demo1 {
    public static final Logger LOGGER = LoggerFactory.getLogger("Demo1");
​
    public static void main(String[] args) {
        LOGGER.info("开始执行div方法");
        div(2,2);
        div(2,0);
    }
    public static int div(int a,int b){
        LOGGER.debug("方法执行了,a="+ a + ",b="+b);
        LOGGER.debug("方法执行了，a={},b={}",a,b);
        LOGGER.warn("除数不能为0");
        try {
            int c = a/b;
            return c;
        }catch (Exception e){
            LOGGER.error("方法执行出错了，出错信息是{}/{}",a,b);
            e.printStackTrace();
            throw new RuntimeException("出错了");
        }
​
    }
}

 

2.2 日志级别

1、设置日志输出级别的作用是什么？

用于控制系统中哪些日志级别是可以输出的

2、Logback的日志级别是什么样的？

ALL 和 OFF分别是打开全部日志和关闭全部日志

级别程度依次是：TRACE< DEBUG< INFO<WARN<ERROR

默认级别是debug（忽略大小写），只输出当前级别及高于该级别的日志

三、多线程

线程
    简单的说，就是计算机在做一件事
​
单线程
    在计算机中同一时间只能做一件事
​
多线程
    在计算机中同一时间可以做多件事
    它的主要好处有：1. 减少队列阻塞带来的影响   2. 提高CPU的利用率

3.1 多线程的创建方式一：继承Thread类

线程的创建方式一：继承Thread类
    1. 定义一个子类继承线程类java.lang.Thread，重写run()方法
    2. 创建子类的对象
    3. 调用子类对象的start()方法启动线程（底层会自动去执行run方法）

优缺点
    优点：编码简单
    缺点：线程类已经继承Thread，无法继承其他类，不利于功能的扩展。

注意事项
    1、启动线程必须是调用start方法,不是调用run方法。
    2、直接调用run方法会当成普通方法执行，只有调用start方法才是启动一个新的线程执行。
    3、不要将主线任务放在start方法之前，这样主线程一直是先跑完的，相当于是一个单线程的效果了。

扩展
    对于单核cpu来讲, 多线程是一种假象

public class Demo1 {
    public static final Logger LOGGER = LoggerFactory.getLogger("Demo1");
    public static void main(String[] args) {
        //需求：创建两个线程，分别用于打印10个A和10个B，最后观察下输出顺序
        // 2. 创建子类的对象
        AThread aThread = new AThread();
        BThread bThread = new BThread();
        // 3. 调用子类对象的start()方法启动线程（底层会自动去执行run方法）
        LOGGER.info("开始执行");
        aThread.start();
        bThread.start();
        // 4. 将耗时多的主线程放在子线程后再执行(主线程和主线程会一起交替运行)
        for (int i = 0; i < 100; i++) {
            System.out.println("main-" + i);
        }
    }
}

// 1. 定义一个子类继承线程类java.lang.Thread，重写run()方法
class AThread extends Thread{
    public static final Logger LOGGER = LoggerFactory.getLogger("AThread");
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            LOGGER.info("A-" + i);
        }
    }
}
class BThread extends Thread{
    public static final Logger LOGGER = LoggerFactory.getLogger("BThread");
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            LOGGER.info("B-" + i);
        }
    }
}

 3.2 多线程的创建方式二：实现Runnable接口

多线程的创建方式二：实现Runnable接口
    1. 定义一个线程任务类实现Runnable接口，重写run()方法
    2. 创建任务类对象
    3. 把任务类对象交给Thread处理
     public Thread(Runnable target)
    4. 调用线程对象的start()方法启动线程

优缺点
 优点：任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强。
 缺点：需要多一个Runnable对象。

public class Demo1 {
    public static void main(String[] args) {
        //需求：创建两个线程，分别用于打印10个A和10个B，最后观察下输出顺序

        //2. 创建任务类对象
        ARunnable aRunnable = new ARunnable();
        BRunnable bRunnable = new BRunnable();
        //3. 把任务类对象交给Thread处理
        Thread thread1 = new Thread(aRunnable);
        Thread thread2 = new Thread(bRunnable);
        //4. 调用线程对象的start()方法启动线程
        thread1.start();
        thread2.start();
    }
}
class ARunnable implements Runnable{
    public static final Logger LOGGER = LoggerFactory.getLogger("ARunnable");
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            LOGGER.info("A-" + i);
        }
    }
}
class BRunnable implements Runnable{
    public static final Logger LOGGER = LoggerFactory.getLogger("BRunnable");
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            LOGGER.info("B-" + i);
        }
    }
}

3.3 多线程的创建方式三：实现Callable接口

多线程的创建方式三：实现Callable接口
    1. 创建任务对象
     定义一个类实现Callable接口，重写call方法，封装要做的事情，和要返回的数据
     把Callable类型的对象封装成FutureTask（线程任务对象）
         public FutureTask<>(Callable call) 把Callable对象封装成FutureTask对象
         public V get() throws Exception    获取线程执行call方法返回的结果
    2. 把线程任务对象交给Thread对象。
    3. 调用Thread对象的start方法启动线程。
    4. 线程执行完毕后、通过FutureTask对象的的get方法去获取线程任务执行的结果

优缺点
 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；可以在线程执行完毕后去获取线程执行的结果
 缺点：编码复杂一点。

FutureTask的API

FutureTask提供的构造器说明
public FutureTask<>(Callable call)把Callable对象封装成FutureTask对象。
FutureTask提供的方法说明
public V get() throws Exception获取线程执行call方法返回的结果。
public class Demo1 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //需求：启动两个子线程，分别计算100之内的奇数的和和偶数的和，然后在主线程中再做个汇总，得到总和

        // 创建Callable的对象
        OddTask oddTask = new OddTask();
        EvenTask evenTask = new EvenTask();
        // 创建FutureTask的对象
        FutureTask<Integer> oddFutureTask = new FutureTask<>(oddTask);
        FutureTask<Integer> evenFutureTask = new FutureTask<>(evenTask);
        // 把FutureTask对象交给Thread对象
        //创建线程对象
        Thread oddThread = new Thread(oddFutureTask);
        Thread evenThread = new Thread(evenFutureTask);
        //调用线程的start方法
        oddThread.start();
        evenThread.start();
        // 获取线程执行call方法返回的结果
        Integer oddSum = oddFutureTask.get();
        Integer evenSum = evenFutureTask.get();
        // 在主线程中再做个汇总，得到总和
        System.out.println("奇数的和为："+oddSum);
        System.out.println("偶数的和为："+evenSum);
        System.out.println("总和为："+(oddSum+evenSum));


    }
}
//计算100之内的奇数的和，并返回
class OddTask implements Callable<Integer>{// 泛型，表示返回的结果类型

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i+=2) {
            sum += i;
        }
        return sum;
    }
}
//计算100之内的偶数的和，并返回
class EvenTask implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i+=2) {
            sum += i;
        }
        return sum;
    }
}

三种线程的创建方式对比

方式优点缺点
继承Thread类编程比较简单，可以直接使用Thread类中的方法扩展性较差，不能再继承其他的类，不能返回线程执行的结果
实现Runnable接口扩展性强，实现该接口的同时还可以继承其他的类。编程相对复杂，不能返回线程执行的结果
实现Callable接口扩展性强，实现该接口的同时还可以继承其他的类。可以得到线程执行的结果编程相对复杂

3.4 Thread类的方法

Thread提供的常用方法说明
public void run()线程的任务方法
public void start()启动线程
public String getName()获取当前线程的名称，线程名称默认是Thread-索引
public void setName(String name)为线程设置名称
public static Thread currentThread()获取当前执行的线程对象
public static void sleep(long time)让当前执行的线程休眠多少毫秒后，再继续执行
public final void join()...让调用当前这个方法的线程先执行完！
Thread提供的常见构造器说明
public Thread(String name)可以为当前线程指定名称
public Thread(Runnable target)封装Runnable对象成为线程对象
public Thread(Runnable target, String name)封装Runnable对象成为线程对象，并指定线程名称
public class Demo1 {

    //需求: 通过下面任务，我们来学习sleep和join方法
    //1. 创建A、B两个线程类，分别打印1~5
    //2. 在主线程序中创建A、B两个子线程
    //3. 在主线程序中开启A、B两个子线程
    //4. 让A线程每打印一次，都要暂停3秒钟
    //5. B线程要等A线程打印完毕，再开始打印
    public static void main(String[] args) throws InterruptedException {
        
        //2. 在主线程序中创建A、B两个子线程
        AThread aThread = new AThread();
        BThread bThread = new BThread();

        //3.1 在主线程序中开启子线程A
        aThread.start();
        //5. B线程要等A线程打印完毕，再开始打印
        aThread.join();
        //3.2 在主线程序中开启子线程B
        bThread.start();

    }
}
//1. 创建A、B两个线程类，分别打印1~5
class AThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("A线程打印了" + i);
            try {
                //4. 让A线程每打印一次，都要暂停3秒钟
                Thread.sleep(3000);//重写父类方法，父类不能抛出异常，子类也不可以，只能try-catch
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

class BThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("B线程打印了" + i);
        }
    }
}

草莓屁屁不酸
关注
  • 36
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Day10-配置文件&日志&多线程】
Doshaxin的博客
09-08 1156
配置文件在企业开发过程中，我们习惯把一些需要灵活配置的数据放在一些文本文件中而不是在Java代码写死我们把这种存放程序配置信息的文件统称为配置文件日志技术可以将系统执行的信息，方便的记录到指定的位置（控制台、文件中、数据库中）。可以随时以开关的形式控制日志的启停，无需侵入到源代码中去进行修改。日志技术的体系结构设计日志框架的一套标准，日志框架需要实现这些接口。牛人或者第三方公司已经做好的实现代码，后来者直接可以拿去使用。注意1因为对接口不满意，有人就搞了SLF4J；因为对。
每日分享之-配置文件&日志&多线程
jayzhang_的博客
09-08 1313
在企业开发过程中，我们习惯把一些需要灵活配置的数据放在一些文本文件中，而不是在Java代码写死 我们把这种存放程序配置信息的文件，统称为配置文件配置文件一般要求有明确的格式，以方便读写操作。
每日筑基之配置文件&日志&多线程
abcdewn的博客
09-08 1215
简单来说就是电脑在做一件事,单线程,在做一件事;多线程,在做多件事。
【Java学习】配置文件&日志&多线程
weixin_69134024的博客
09-08 1482
程序中的日志，通常就是一个文件，里面记录的是程序运行过程中的各种信息。日志会展示在控制台不能更方便的将日志记录到其他的位置（文件，数据库）想取消日志，需要修改源代码才可以完成在实际项目开发中就会使用日志技术，可以将系统执行的信息，方便的记录到指定的位置（控制台、文件中、数据库中）。也可以随时以开关的形式控制日志的启停，无需侵入到源代码中去进行修改。日志接口：设计日志框架的一套标准，日志框架需要实现这些接口。日志框架：大佬或者第三方公司已经做好的实现代码，后来者直接可以拿去使用。
day20--特殊文件、日志技术、多线程
ZHUSHANGLIN的博客
05-29 697
首先，我们来认识一下，什么是XML？XML是可扩展的标记语言，意思是它是由一些标签组成 的，而这些标签是自己定义的。本质上一种数据格式，可以用来表示复杂的数据关系。XML中的称为一个标签或者一个元素，一般是成对出现的。XML中的标签名可以自己定义（可扩展），但是必须要正确的嵌套XML中只能有一个根标签。XML标准中可以有属性XML必须第一行有一个文档声明，格式是固定的XML文件必须是以.xml为后缀结尾如下图所示接下，同学们可以跟着步骤新建一个XML文件，试试！>
黑马头条-day04&day05
hmmmgo的博客
02-12 1491
点击这里进行学习。1、定义feign接口2、定义跟feign接口对应的controller接口3、调用feign接口。
kafka 2.13-2.8.0 单机 & 集群配置（zookeeper）
疯飙的蜗牛
11-10 2198
1、配置预安装环境，下载kafka yum -y install java-1.8.0-openjdk.x86_64 wget https://archive.apache.org/dist/kafka/2.8.0/kafka_2.13-2.8.0.tgz tar -xvf kafka_2.13-2.8.0.tgz mv kafka_2.13-2.8.0 kafka cd kafka/ 2、配置并启动zookeeper mkdir zklogs vim config/zookeeper.prop
mysql的日志文件
左直拳的马桶_日用桶
03-24 3222
上回说到数据库的备份与恢复，日志文件在其中占有很重要的位置。 但是，我查了下资料，发现想搞懂这个数据库日志其实并不容易。包括网上许多文章，说了许多，但我越看越糊涂。只有一些mysql的日志文件原理介绍，相对好一些。mysql因为应用广泛，使用者众，作为数据库的学习对象，也算有代表性。 一、MySQL的日志文件 MySQL中有七种日志文件，分别是： 重做日志（redo log） 回滚日志（undo log） 二进制日志（binlog） 错误日志（errorlog） 慢查询日志（slow query log）
SpringBoot-21-异步&定时任务
paiidds的博客
04-12 2591
异步任务&定时任务   异步任务   异步任务知识介绍 在多线程时，后台执行多个任务，我们需要同步等待。此时前台不会给出任何响应，可以采用多线程 的方式解决这个问题。 SpringBoot采用异步注解的方式来解决这个问题，让我们在同步等待的时候，响应前台页面，无需 等待，后台代码执行依旧 实现异步任务        在SpringBoot实现异步任务很简单，在同步等待的任务中添加@Async注解，然后在SpringBoot添加@EnableAsync 代码实现 在com.liang.se
day020-继承加强和设计模式代码和笔记.rar
03-15
传统方式获取流是new创建的，而在web开发中有可能获取不到配置文件，为了避免这种情况，用以下方式获取流： 1. 通过当前类字节码文件的方式，一般是用当前类的字节码文件 当前类.class....
JavaWeb-day02&day03
夕月希的博客
08-23 1334
思考：如何在登录成功后显示一个网页而不是一段文本1.转发不会改变地址栏，重定向会2.转发只发送一个请求，重定向是两次请求3.转发操作请求，重定向操作重定向4.转发可以获取request作用域数据，重定向不能5.转发只能转发服务器已有的资源，重定向可以重定向到外部资源​ 作用在整个应用范围内，多个session Http协议响应状态码 什么是Http？Http是一种无状态协议。请求行：存储请求的url请求头：浏览器信息、系统信息、cookie、请求类型…请求体：例如：上传文件的文件数据、P
tomcat服务器日志文件配置
iOS逆向与安全
08-21 105
这个配置项通常在MyBatis的配置文件（比如mybatis-config.xml）或者Spring Boot的application.properties或application.yml文件中进行设置。来记录从接收到请求到发送响应的总时间，单位毫秒，对应的日志文件是 localhost_access_log.xxx.txt。修改server.xml 文件，日志格式包含。
framework学习笔记day05---Spring基础
Wynb1020的博客
12-24 256
Spring Spring简介 spring是分层的JavaSE及JavaEE应用于全栈的轻量级开源框架，以IoC（Inverse Of Control：控制反转/反转控制）和AOP（Aspact Oriented Programming：面向切面编程）为核心，提供了表现层SpringMVC和持久层Spring JDBC以及业务层事务管理等众多模块的企业级应用技术，还能整合开源世界中众多著名的第三方框架和类库，逐渐成为使用最多的JavaEE企业应用开源框架。 SSH(struts2 spring hiber
spring事务详细讲解-深入浅出
小电玩
09-08 469
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1453
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 523
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 539
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
自定义Stater
m0_63624484的博客
09-07 717
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
cd "d:\code\day1\" && gcc test.c -o test && "d:\code\day1\"test
07-28
你可以使用以下命令在 Windows 上编译和运行 C 代码： ``` cd "d:\code\day1\" && gcc test.c -o test && "d:\code\day1\test" ``` 这个命令将首先切换到 `d:\code\day1\` 目录，然后使用 `gcc` 编译 `test.c` 文件，并将可执行文件命名为 `test.exe`。最后，它会运行生成的可执行文件。 请确保你已经在 `d:\code\day1\` 目录下，并且已经安装并配置好了 GCC 编译器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值