Spring【 Spring整合MyBatis、SpringAOP（AOP简介 、AOP相关术语、AOP入门）】(五)-全面详解（学习总结---从入门到深化）

news2024/11/17 0:03:37

目录

 Spring整合MyBatis_准备数据库和实体类

Spring整合MyBatis_编写持久层接口和service类

Spring整合MyBatis_Spring整合Junit进行单元测试

Spring整合MyBatis_自动创建代理对象 

SpringAOP_AOP简介 

 SpringAOP_AOP相关术语

 SpringAOP_AOP入门

 Spring整合MyBatis_准备数据库和实体类

准备数据库

CREATE DATABASE `student`;
USE `student`;
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `sex` varchar(10) DEFAULT NULL,
  `address` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT
CHARSET=utf8;
insert  into
`student`(`id`,`name`,`sex`,`address`)
values (1,'程序员','男','北京'),(2,'程序媛','女','北京');

准备实体类

public class Student {
    private int id;
    private String name;
    private String sex;
    private String address;
    
    // 省略构造方法/getter/setter/tostring
}

Spring整合MyBatis_编写持久层接口和service类

编写持久层接口

@Repository
public interface StudentDao {
    // 查询所有学生
    @Select("select * from student")
    List<Student> findAll();
    // 添加学生
    @Insert("insert into student values(null,#{name},#{sex},#{address})")
    void add(Student student);
}

编写service类

@Service
public class StudentService {
    // SqlSession对象
    @Autowired
    private SqlSessionTemplate sqlSession;
    // 使用SqlSession获取代理对象
    public List<Student> findAllStudent(){
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        return studentDao.findAll();
   }
}

Spring整合MyBatis_Spring整合Junit进行单元测试

之前进行单元测试时都需要手动创建Spring容器，能否在测试时让 Spring自动创建容器呢？

1 、引入Junit和Spring整合Junit依赖

<!-- junit,如果Spring5整合junit，则junit版本
至少在4.12以上 -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<!-- spring整合测试模块 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.3.13</version>
</dependency>

2 、编写测试类

// JUnit使用Spring方式运行代码，即自动创建spring容器。
@RunWith(SpringJUnit4ClassRunner.class)
// 告知创建spring容器时读取哪个配置类或配置文件
// 配置类写法：
@ContextConfiguration(classes=配置类.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class StudentServiceTest {
    @Autowired
    private StudentService studentService;
    
    @Test
    public void testFindAll(){
        List<Student> allStudent = studentService.findAllStudent();
        allStudent.forEach(System.out::println);
   }
}

注：使用SqlSessionTemplate创建代理对象还是需要注册接口 或者映射文件的。

1、在MyBatis配置文件注册接口

<configuration>
    <mappers>
        <mapper class="com.tong.dao.StudentDao"></mapper>
    </mappers>
</configuration>

2、创建sqlSessionFactory时指定MyBatis配置文件

<!-- 创建Spring封装过的SqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"></property>
    <property name="configLocation" value="classpath:SqlMapConfig.xml"></property>
</bean>

Spring整合MyBatis_自动创建代理对象 

Spring提供了MapperScannerConfigurer对象，该对象可以自动扫 描包创建代理对象，并将代理对象放入容器中，此时不需要使用 SqlSession手动创建代理对象。

1、创建MapperScannerConfigurer对象

<!-- 该对象可以自动扫描持久层接口，并为接口创建代理对象 -->
<bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <!-- 配置扫描的接口包 -->
    <property name="basePackage" value="com.tong.dao"></property>
</bean>

2、Service类直接使用代理对象即可

@Service
public class StudentService {
    // 直接注入代理对象
    @Autowired
    private StudentDao studentDao;
  
    // 直接使用代理对象
    public void addStudent(Student student){
        studentDao.add(student);
   }
}

3、测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath :applicationContext.xml")
public class StudentServiceTest {
    @Autowired
    private StudentService studentService;
    
    @Test
    public void testAdd(){
        Student student = new Student(0, "童小纯", "男", "上海");
        studentService.addStudent(student);
   }
}

SpringAOP_AOP简介 

 AOP的全称是Aspect Oriented Programming，即面向切面编程。 是实现功能统一维护的一种技术，它将业务逻辑的各个部分进行隔 离，使开发人员在编写业务逻辑时可以专心于核心业务，从而提高 了开发效率。

作用：在不修改源码的基础上，对已有方法进行增强。

实现原理：动态代理技术。

优势：减少重复代码、提高开发效率、维护方便

应用场景：事务处理、日志管理、权限控制、异常处理等方面。

 SpringAOP_AOP相关术语

 为了更好地理解AOP，就需要对AOP的相关术语有一些了解

 SpringAOP_AOP入门

AspectJ是一个基于Java语言的AOP框架，在Spring框架中建议使用 AspectJ实现AOP。

接下来我们写一个AOP入门案例：dao层的每个方法结束后都可以 打印一条日志：

1、引入依赖

<!-- spring -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.13</version>
</dependency>

<!-- AspectJ -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.7</version>
</dependency>

<!-- junit -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

2、编写连接点

@Repository
public class UserDao {
    public void add(){
        System.out.println("用户新增");
   }
    public void delete(){
        System.out.println("用户删除");
   }
    public void update(){
        System.out.println("用户修改");
   }
}

3、编写通知类

public class MyAspectJAdvice {
    // 后置通知
    public void myAfterReturning() {
        System.out.println("打印日志...");
   }
}

4、配置切面

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:context="http://www.springframework.org/schema/context"
      xmlns:aop="http://www.springframework.org/schema/aop"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <context:component-scan base-package="com.tong"></context:component-scan>
    <!-- 通知对象 -->
    <bean id="myAspectJAdvice" class="com.tong.advice.MyAspectAdvice"></bean>
    <!-- 配置AOP -->
    <aop:config>
    <!-- 配置切面 -->
        <aop:aspect ref="myAspectJAdvice">
            <!-- 配置切点 -->
            <aop:pointcut id="myPointcut" expression="execution(* com.tong.dao.UserDao.*(..))"/>
            <!-- 配置通知 -->
            <aop:after-returning method="myAfterReturning" pointcutref="myPointcut"/>
        </aop:aspect>
    </aop:config>
</beans>

5、测试

public class UserDaoTest {
    @Test
    public void testAdd(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        UserDao userDao = (UserDao) ac.getBean("userDao");
        userDao.add();
   }
    @Test
    public void testDelete(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        UserDao userDao = (UserDao)ac.getBean("userDao");
        userDao.delete();
   }
    @Test
    public void testUpdate(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        UserDao userDao = (UserDao) ac.getBean("userDao");
        userDao.update();
   }
}

复习：

Spring简介

 Spring是一个开源框架，为简化企业级开发而生。它以IOC（控制 反转）和AOP（面向切面）为思想内核，提供了控制层 SpringMVC、数据层SpringData、服务层事务管理等众多技术，并 可以整合众多第三方框架。 Spring将很多复杂的代码变得优雅简洁，有效的降低代码的耦合 度，极大的方便项目的后期维护、升级和扩展。

Spring官网地址：https://spring.io/

 Spring体系结构

 Spring框架根据不同的功能被划分成了多个模块，这些模块可以满 足一切企业级应用开发的需求，在开发过程中可以根据需求有选择 性地使用所需要的模块。

1、Core Container：Spring核心模块，任何功能的使用都离不开该模块，是其他模块建立的基础。

2、Data Access/Integration：该模块提供了数据持久化的相应功能。

3、Web：该模块提供了web开发的相应功能。

4、AOP：提供了面向切面编程实现

5、Aspects：提供与AspectJ框架的集成，该框架是一个面向切面编程框架。

6、Instrumentation：提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使 用。

7、Messaging：为Spring框架集成一些基础的报文传送应用

8、Test：提供与测试框架的集成

IOC_控制反转思想 

 IOC(Inversion of Control) ：程序将创建对象的权利交给框架。 之前在开发过程中，对象实例的创建是由调用者管理的，代码如下：

public interface StudentDao {
    // 根据id查询学生
    Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{
    @Override
    public Student findById(int id) {
        // 模拟从数据库查找出学生
        return new Student(1,"程序员","北京");
   }
}
public class StudentService {
    public Student findStudentById(int id){
        // 此处就是调用者在创建对象
        StudentDao studentDao = new StudentDaoImpl();
        return studentDao.findById(1);
   }
}

这种写法有两个缺点：

1 浪费资源：StudentService调用方法时即会创建一个对象，如果 不断调用方法则会创建大量StudentDao对象。

2 代码耦合度高：假设随着开发，我们创建了StudentDao另一个 更加完善的实现类StudentDaoImpl2，如果在StudentService 中想使用StudentDaoImpl2，则必须修改源码。

而IOC思想是将创建对象的权利交给框架，框架会帮助我们创建对 象，分配对象的使用，控制权由程序代码转移到了框架中，控制权 发生了反转，这就是Spring的IOC思想。而IOC思想可以完美的解决以上两个问题。 

IOC_自定义对象容器

 接下来我们通过一段代码模拟IOC思想。创建一个集合容器，先将 对象创建出来放到容器中，需要使用对象时，只需要从容器中获取 对象即可，而不需要重新创建，此时容器就是对象的管理者。

创建实体类

public class Student {
    private int id;
    private String name;
    private String address;
 // 省略getter/setter/构造方法/tostring
}

创建Dao接口和实现类

public interface StudentDao {
    // 根据id查询学生
    Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{
    @Override
    public Student findById(int id) {
        // 模拟从数据库查找出学生
        return new Student(1,"程序员","北京");
   }
}
public class StudentDaoImpl2 implements StudentDao{
    @Override
    public Student findById(int id) {
        // 模拟根据id查询学生
        System.out.println("新方法！！！");
        return new Student(1,"程序员","北京");
   }
}

创建配置文件bean.properties，该文件中定义管理的对象

studentDao=com.tong.dao.StudentDaoImpl

创建容器管理类，该类在类加载时读取配置文件，将配置文件中 配置的对象全部创建并放入容器中。

public class Container {
    static Map<String,Object> map = new HashMap();
    static {
        // 读取配置文件
        InputStream is = Container.class.getClassLoader().getResourceAsStream("bean.properties");
        Properties properties = new Properties();
        try {
            properties.load(is);
       } catch (IOException e) {
            e.printStackTrace();
       }
        // 遍历配置文件的所有配置
        Enumeration<Object> keys = properties.keys();
        while (keys.hasMoreElements()){
            String key = keys.nextElement().toString();
            String value = properties.getProperty(key);
            try {
                // 创建对象
                Object o = Class.forName(value).newInstance();
                // 将对象放入集合中
                map.put(key,o);
           } catch (Exception e) {
                e.printStackTrace();
           }
       }
   }
    // 从容器中获取对象
 public static Object getBean(String key){
        return map.get(key);
   }
}

创建Dao对象的调用者StudentService

public class StudentService {
    public Student findStudentById(int id)
     {
        // 从容器中获取对象
        StudentDao studentDao = (StudentDao) Container.getBean("studentDao");
        System.out.println(studentDao.hashCode());
        return studentDao.findById(id);
   }
}

测试StudentService

public class Test {
    public static void main(String[] args)
    {
      StudentService studentService = new StudentService();
      System.out.println(studentService.findStudentById(1));
      System.out.println(studentService.findStudentById(1));
   }
}

 IOC_Spring实现IOC

 接下来我们使用Spring实现IOC，Spring内部也有一个容器用来管 理对象。

创建Maven工程，引入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.13</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

创建POJO类、Dao类和接口

public class Student {
    private int id;
    private String name;
    private String address;
  // 省略getter/setter/构造方法/tostring
}
public interface StudentDao {
    // 根据id查询学生
    Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{
    @Override
    public Student findById(int id) {
        // 模拟从数据库查找出学生
        return new Student(1,"程序员","北京");
   }
}

编写xml配置文件，配置文件中配置需要Spring帮我们创建的对象。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="studentDao" class="com.tong.dao.StudentDaoImpl"></bean>     
</beans>

 测试从Spring容器中获取对象。            

public class TestContainer {
    @Test
    public void t1(){
        // 创建Spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // 从容器获取对象
        StudentDao studentDao1 = (StudentDao) ac.getBean("studentDao");
        StudentDao studentDao2 = (StudentDao) ac.getBean("studentDao");
        System.out.println(studentDao1.hashCode());
        System.out.println(studentDao2.hashCode());
        System.out.println(studentDao1.findById(1));
   }
}

 IOC_Spring容器类型                                                                     容器接口                            

 1、BeanFactory：BeanFactory是Spring容器中的顶层接口，它可 以对Bean对象进行管理。

2、ApplicationContext：ApplicationContext是BeanFactory的子 接口。它除了继承 BeanFactory的所有功能外，还添加了对国际 化、资源访问、事件传播等方面的良好支持。

 ApplicationContext有以下三个常用实现类：、

容器实现类

1、ClassPathXmlApplicationContext：该类可以从项目中读取配置文件

2、FileSystemXmlApplicationContext：该类从磁盘中读取配置文件

3、AnnotationConfigApplicationContext：使用该类不读取配置文件，而是会读取注解

@Test
public void t2(){
    // 创建spring容器
    //       ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    ApplicationContext ac = new FileSystemXmlApplicationContext("C:\\Users\\a\\IdeaProjects\\spring_demo\\src\\main\\resources\\bean.xml");
    
    // 从容器中获取对象
    StudentDao userDao = (StudentDao)ac.getBean("studentDao");
    System.out.println(userDao);
    System.out.println(userDao.findById(1));
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/757216.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

推荐几个github上非常受欢迎的库

推荐几个github上非常受欢迎的库

推荐几个github上非常受欢迎的库 The Book of Secret Knowledge the-book-of-secret-knowledge 这个仓库里边包含了一系列非常有趣的手册、备忘单、博客、黑客、单行话、cli/web 工具等。 Coding Interview University coding-interview-university 这里列出的项目可以帮助…
阅读更多...
基于Ubuntu20.4的TMS320C6678开发环境（CCS8.3.1）的搭建

基于Ubuntu20.4的TMS320C6678开发环境（CCS8.3.1）的搭建

网上关于ccs的安装大多是基于ccs5及以前的版本安装介绍或基于windows版本的ccs软件的安装,没有关于linux系统上安装CCS8.3.1的集成开发环境。本文介绍在ubuntu20.4的系统上安装ccs8.3.1的DSP开发环境&#xff0c;本文包括CCS软件和插件的下载&#xff0c;安装。本文在ubuntu20.…
阅读更多...
fpga下载程序到flash后无法在重新上电后自动加载程序

fpga下载程序到flash后无法在重新上电后自动加载程序

可能是接的调试器没有断电&#xff0c;断电一次再给调试器上电。如果调试器一直连着可以连续断电上电fpga开发板&#xff0c;直到成功。fpga貌似上电后什么程序都不加载则引脚为高电平&#xff0c;而vivado默认.xdc的BITSTREAM.CONFIG.UNUSEDPIN&#xff08;未使用的引脚&#…
阅读更多...
vue3 - 01搭建工程

vue3 - 01搭建工程

1. 使用vue-cli创建工程 1. 命令&#xff1a;vue create xxx2. 选择vue3版本3. 进入目录4. 运行&#xff1a; npm run serve 在执行完运行指令后如果报错请查看是否是以下错误&#xff0c;如果是可以按以下步骤进行解决&#xff1a; ERROR in Conflict: Multiple assets emit …
阅读更多...
命令执行绕过

命令执行绕过

首先以一道BUUCTF题目来开下胃 查看flag&#xff1a; 其次给大家上主菜-----命令执行绕过 命令执行漏洞绕过方式&#xff1a; 管道符 windows中常见管道符&#xff1a; | 直接执行后面的语句 || 如果前面命令是错的那么就执行后面的语句&#xff0c;否则只执行前面的语…
阅读更多...
DEV C++ 更改界面语言

DEV C++ 更改界面语言

第一步&#xff1a;选中tools&#xff0c;然后从里面找Environment optional 第二步&#xff1a;从里面找到Language选项&#xff0c;找到简体中文 选中简体中文后点击“OK”就可以了
阅读更多...
go语言 socket: too many open files 错误分析

go语言 socket: too many open files 错误分析

问题背景&#xff1a; 近期针对老的PHP接口做了迁移重构&#xff0c;用golang重新实现&#xff0c;在上线之前&#xff0c;测试进行了压测&#xff0c;压测的量级为&#xff1a;200请求/s, 连续请求10s&#xff0c;发现接口出现大量超时错误&#xff0c;查看日志发现错误信息为…
阅读更多...
前缀和模板算法

前缀和模板算法

一)模板前缀和 【模板】前缀和_牛客题霸_牛客网 (nowcoder.com) 前缀和:快速的得出数组中某一段连续区间的和 暴力破解的话需要从头到尾的进行遍历&#xff0c;时间复杂度就可以达到O(N)&#xff0c;而前缀和时间复杂度是可以达到O(1)的 第一步:预处理创建出一个前缀和数组dp&a…
阅读更多...
RTMP简介

RTMP简介

简介 RTMP协议是Real Time Message Protocal(实时传输协议的缩写)&#xff0c;同时Adobe公司提供的一种应用层协议&#xff0c;用来解决多没意思数据流传输的 多路复用和分包问题。 RTMP是应用层协议&#xff0c;采用TCP来保证可靠的传输在TCP完成握手连接建立后&#xff0c…
阅读更多...
【动手学深度学习】--03.多层感知机MLP

【动手学深度学习】--03.多层感知机MLP

文章目录 多层感知机1.原理1.1感知机1.2多层感知机MLP1.3激活函数 2.从零开始实现多层感知机2.1初始化模型参数2.2激活函数2.3 模型2.4损失函数2.5训练 3.多层感知机的简洁实现3.1模型3.2训练 多层感知机 1.原理 官方笔记&#xff1a;多层感知机 1.1感知机 训练感知机 收敛定…
阅读更多...
SEO 基础知识? 2023学习SEO最佳指南

SEO 基础知识? 2023学习SEO最佳指南

文章目录 搜索引擎优化基础知识什么是搜索引擎优化&#xff1f;为什么搜索引擎优化很重要&#xff1f;SEO有什么好处&#xff1f;如何做搜索引擎优化关键词研究内容优化网站结构优化&#xff08;页面SEO&#xff09;外部链接优化移动优化分析和迭代(技术SEO) 为 SEO 成功做好准…
阅读更多...
蓝牙技术|低功耗蓝牙和LE Audio助力游戏设备行业发展

蓝牙技术|低功耗蓝牙和LE Audio助力游戏设备行业发展

去年&#xff0c;蓝牙技术联盟官方宣布推出LE Audio&#xff0c;它以BLE为基础&#xff0c;旨在更好地兼顾音频质量和低功耗&#xff0c;以在多种潜在应用中显著增强用户体验。这在游戏行业中引起了轰动&#xff0c;由于其延迟显著降低&#xff0c;LE Audio在增强游戏体验方面展…
阅读更多...
单片机第一季：零基础9——直流电机和步进电机

单片机第一季：零基础9——直流电机和步进电机

目录 1&#xff0c;直流电机 2&#xff0c;步进电机 1&#xff0c;直流电机 直流电机是指能将直流电能转换成机械能&#xff08;直流电动机&#xff09;或将机械能转换成直流电能&#xff08;直流发电机&#xff09;的旋转电机。它是能实现直流电能和机械能互相转换的电机。…
阅读更多...
Jenkins的安装部署以及基本使用

Jenkins的安装部署以及基本使用

前言&#xff1a; 今天有空大概记录的一个作为一个测试人员日常中Jenkins的使用。 一、环境准备 在安装使用Jenkins前我们要先安装jdk&#xff0c;这里博主选择的是jdk11。我们先删除旧的jdk然后安装全新的jdk。 1、先看下当前我们的jdk版本。 2、查看jdk安装路径&#xff1…
阅读更多...
Simulink仿真模块 - Unit Delay

Simulink仿真模块 - Unit Delay

Unit Delay:将信号延迟一个采样期间 在仿真库中的位置为：Simulink / Discrete HDL Coder / Discret 模型为： 双击模型打开参数设置界面，如图所示： 说明 Unit Delay 模块按指定的采样期间保持和延迟输入。当放置于迭代子系统中时，该模块将其输入保持并延迟一个迭代。此…
阅读更多...
视频文件一键批量去除水印需要用到什么剪辑软件

视频文件一键批量去除水印需要用到什么剪辑软件

刚接触视频剪辑这个行业的小伙伴在找视频素材的过程中&#xff0c;如果发现视频带有水印是不是非常头疼&#xff0c;不知道怎么处理这件事。那今天我们就来聊聊怎么才能快速批量去除视频的水印呢&#xff1f;今天小编给大家带来一个好方法&#xff0c;一起来看看吧。 一、首先我…
阅读更多...
Redis实战案例17-Redisson可重入的原理

Redis实战案例17-Redisson可重入的原理

可重入原理分析 为什么自定义的Redis实现分布式锁不能实现可重入 method1中调用了method2方法&#xff0c;属于是同一线程内的操作&#xff0c;但是当method1中获取了锁之后&#xff0c;method2中就无法获取锁了&#xff0c;这就是同一线程无法实现可重入&#xff1b; 如何解决…
阅读更多...
Windows上查看服务器上tensorboad内容

Windows上查看服务器上tensorboad内容

文章目录 前言一、SSH的设置二、tensorboard命令 前言 本篇文章是针对于局域网内的服务器的tensorboard可视化&#xff0c;由于设置方式稍微有点复杂&#xff0c;导致我每次隔了一段时间之后&#xff0c;就不知道该怎么查看tensorboard了&#xff0c;每次都要百度搜一大堆资料…
阅读更多...
安达发|选择APS排程系统一定要注意这五大问题

安达发|选择APS排程系统一定要注意这五大问题

随着信息技术的迅速发展&#xff0c;云计算已成为企业信息化建设的重要领域。在云计算中&#xff0c;aps是企业服务器环境中常见的虚拟化解决方案。然而&#xff0c;市场上有许多aps系统可供选择&#xff0c;企业在选择合适的系统时需要综合考虑多种因素。本论文将从这个五个角…
阅读更多...
nacos十分钟快速搭建

nacos十分钟快速搭建

简介 nacos是阿里巴巴开源的微服务基础组件&#xff0c;充当微服务架构中的配置中心和注册中心&#xff0c;nacos可单独作为配置中心或者注册中心 目录结构 bin&#xff0c;bin工具 conf&#xff0c;配置文件 target&#xff0c;nacos的jar包 安装 机器环境&#xff1a;cen…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023