1. 全栈程序员必看首页

Spring的基本配置和Spring与Mybatis的整合

全栈程序员-用户IM • • 未分类

Spring的基本配置和Spring与Mybatis的整合Spring:        Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由RodJohnson在其著作ExpertOne-On-OneJ2EEDevelopmentandDesign中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪…

大家好，又见面了，我是你们的朋友全栈君。

Spring: 

             Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核心是控制反转（IOC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架

 

Spring的优点：

  1.  方便解耦，简化开发 （高内聚低耦合）                                                                                                                            Spring就是一个大工厂（容器）， Spring工厂是用于生成bean，可以将所有对象创建和依赖关系维护，交给Spring管理                                               
  2.  AOP编程的支持 
    Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
  3.  声明式事务的支持                                                                                                                                                             只需要通过配置就可以完成对事务的管理，而无需手动编程
  4. 方便程序的测试 
    Spring对Junit4支持，可以通过注解方便的测试Spring程序
  5. 方便集成各种优秀框架 
    Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis等）的直接支持，方便整合其他框架
  6. 降低JavaEE API的使用难度 
    Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低
     

 

Spring的控制反转（IOC）：

    Inversion of Control 又称为 依赖注入 (DI)  Dependency Injection                                                                                      把对象的创建和方法的调用的控制权(反转)交由给容器管理，由容器控制程序之间的依赖关系                                                IOC就是一个生产和管理bean的容器就行了，原来需要在调用类中new的东西，现在都是通过容器生成                                同时，要是产生的是单例的bean，他还可以给管理bean的生命周期

IOC理解：

它并不是一种技术实现，而是一种设计思想。在任何一个有实际开发意义的程序项目中，我们会使用很多类来描述它们特有的功能，并且通过类与类之间的相互协作来完成特定的业务逻辑。这个时候，每个类都需要负责管理与自己有交互的类的引用和依赖，代码将会变的异常难以维护和极度的高耦合。而IOC的出现正是用来解决这个问题，我们通过IOC将这些相互依赖对象的创建、协调工作交给Spring容器去处理，每个对象只需要关注其自身的业务逻辑关系就可以了。在这样的角度上来看，获得依赖的对象的方式，进行了反转，变成了由spring容器控制对象如何获取外部资源（包括其他对象和文件资料等等）
 

IOC和DI的区别：

  1.   IOC：控制反转，把创建对象交给Spring进行配置
  2.   DI：   依赖注入，向类里面的属性中赋值

 

Spring的面向切面编程（AOP）：

将程序中的交叉业务逻辑（比如安全，日志，事务等），封装成一个切面，然后注入到目标对象（具体业务逻辑）中去。 比如： 很多方法可能会抛异常，你要记录这个异常到日志中去，可以写个拦截器类，在这个类中记录日志，在spring.xml中配置一个对这些要记录日志的方法的aop拦截器 在这个方法执行后调用这个拦截器，记录日志。这样就不用每次抛异常都要手动记录日志。 spring的事务管理用到的就是aop 这样也可以提高程序的内聚性

 

Spring的基本使用：

   1）用maven创建一个项目，在 pom.xml 文件中加入 spring的依赖（jar包）

                          Spring的基本配置和Spring与Mybatis的整合

    2）在 resource 目录下，编写 spring.xml 配置文件，并定义要控制反转的类  <bean></bean>

                         Spring的基本配置和Spring与Mybatis的整合

       ***注意***：

  1.   bean 的 id是严格区分大小写的 如果id不存在会报错： NoSuchBeanDefinitionException    
  2.   如果容器中同一个类型的bean有多个，再根据类型获取的话就会报错： NoUniqueBeanDefinitionException 
  3.   bean一般需要无参构造，spring会调用它来创建对象
       如果没有无参构造，需要给构造方法的参数赋值：    <constructor-arg index=”参数下标” value=”值”/>
  4.   默认情况下，每个类型的bean在容器中只有一个对象（单例） <bean scope=”singleton“>                                            多例，每用一次，创建一个新的对象, 如果配置多例                  <bean scope=”prototype“>
  5.   初始化方法 和 销毁方法： <bean init-method=”初始化方法名()“ destory-method=”销毁方法名()” >                                        

            单例：单例对象既会调用初始化方法，也会调用销毁方法

            多例：每使用一个多例对象都会调用初始化方法，但所有的多例对象都不会调用销毁方法

 

 

         3）在测试类中使用 spring容器 进行测试

                         Spring的基本配置和Spring与Mybatis的整合

 

依赖注入的三种方式：

        1) set注入：   property  配合 setXXX() 方法

             测试代码：

    /**
     * 1) set注入
     */

  public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
  }

             spring.xml 配置:

<bean id="userService" class="com.chen.service.UserService">
        <!-- 1) set注入-->
        <property name="userDao" ref="userDao"/>
</bean>

        2) 构造注入： constructor-arg 配合构造函数

               测试代码：

     /**
      *  2) 构造注入
      */

    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }

            spring.xml 配置:

<bean id="userService" class="com.chen.service.UserService">
    
       <!-- 2) 构造注入 -->
       <constructor-arg index="0" ref="userDao"/>
</bean>

       3) 注解注入： @AutoWired | @Resource 配合 <context:annotation-config/>(启动注解，否则spring无法解析注解)                                                利用这个注解完成属性的赋值，把它加在需要注入的属性上, 或set方法上，或构造方法上

          测试代码：

    /**
     * 3) 注解注入 ： 利用反射，找到该变量的类型，自动赋值
     */
     @Autowired | @Resource
     private UserDao userDao;

         spring.xml 配置:     

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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">

    <!-- 3) 启动注解 -->
    <context:annotation-config/>

         

 将 *.properties 注入到spring.xml中：

                         方便以后修改，只修改 *.properties 中的内容，不改动 spring.xml 中的配置

<!--
   读取properties 文件 
        location="文件位置" 
        placeholder 占位符
-->
<context:property-placeholder location="classpath:jdbc.properties"/>


<!-- 
     可以利用 ${key} 获取 *.properties 文件中的值
-->
<bean id="productDao" class="com.westos.dao.ProductDao">
	<property name="username" value="${jdbc.username}"/>
	<property name="password" value="${jdbc.password}"/>
</bean>

注解方式 @Value 也可以完成这种 值注入
@Value("${properties中的key}")

 

Spring和Mybatis整合：

      方法一： 通过 XXXMapper.xml 映射文件整合

                1）配置 pom.xml 文件，加入所需要的依赖

    <dependencies>
        <!-- spring jar 包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.18.RELEASE</version>
        </dependency>

        <!-- junit jar 包-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <!-- mysql 的驱动包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.12</version>
        </dependency>

        <!--logback 日志包-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

        <!-- mybatis jar 包-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>

        <!-- 数据库连接池 alibaba 的 druid  -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.7</version>
        </dependency>

        <!-- mybatis与spring整合的jar包-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>

        <!--spring管理的 jdbc ,以及事务相关的-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.3.17.RELEASE</version>
        </dependency>
    </dependencies>

      2）把关键对象的创建交给 spring 控制反转（IOC）,生成<bean>：连接池对象，SqlSessionFactory工厂类,SqlSession对象

<?xml version="1.0" encoding="UTF-8" ?>
<!-- xmlns 是xml的命名空间
    要引入新的 context命名空间
-->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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">

    <!--
       读取 jdbc.properties 中的内容
            property-placeholder: 占位符
            location： 属性文件的位置
    -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 1) 获得数据库连接池对象，并交由 spring 同一管理 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">

        <!-- 连接数据库的驱动，连接字符串，用户名和登录密码-->
        <property name="driverClassName" value="${drivername}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${password}"/>

        <!-- 数据池中最大连接数和最小连接数-->
        <property name="maxActive" value="${max}"/>
        <property name="minIdle" value="${min}"/>
    </bean>

    <!-- 2) 获取 SqlSessionFactory 对象，并交由 spring 管理-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入连接池
         给 sqlsessionFactory 的属性 dataSource 赋值
            ref="引用该 spring容器 中的另一个 bean的id"
        -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 注入 映射文件 mapper
         给 sqlsessionFactory 的属性 mapperLocation 赋值
           value="映射文件 XXXmapper.xml 的相对路径"
          -->
        <property name="mapperLocations" value="classpath:com/chen/mapper/*.xml"/>
    </bean>

    <!-- 3) 获取 SqlSession 对象，并交由 spring 管理  用SqlSessionTemplate得到的SqlSession可以不用我们自己操心事务的管理，以及关闭操作-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!-- 给 SqlSessionTemplate 的构造函数赋值-->
        <constructor-arg index="0" ref="sqlSessionFactory" />
    </bean>
</beans>

        3）配置 XXXMapper.xml 映射文件   

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.chen.mapper.ProductMapper">
    <select id="selectPage" parameterType="map" resultType="com.chen.entity.Product">
        select id,name from product limit #{start},#{size}
    </select>
</mapper>

 

          4)  使用 SqlSession 进行操作

public class SpringMybatisTest {
    /*
    * 1. 创建spring容器
           根据xml文件应用程序Context容器(上下文)
           classpath指配置文件的位置, 起点有java, resources. 写路径时相对这个起点去写
    * */
    static ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring.xml");

    @Test
    public void test1(){

        /* 得到 SqlSession 对象*/
        SqlSession sqlSession = (SqlSession) context.getBean("sqlSession");

        Map<String, Object> map = new HashMap<String, Object>();
        map.put("start",0);
        map.put("size",5);

        // 调用 Mapper映射文件里的方法
        List<Product> list = sqlSession.selectList("com.chen.mapper.ProductMapper.selectPage", map);

        for (Product product : list) {
            System.out.println(product);
        }
    }
}

   方法二：通过 Mapper接口的方式整合

      1） 在配置文件 pom.xml 中加入依赖 

 <dependencies>
        <!-- spring 容器相关 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.17.RELEASE</version>
        </dependency>
        <!-- spring jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.3.17.RELEASE</version>
        </dependency>
        <!-- mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <!-- 与spring整合 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>
        <!-- 数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.12</version>
        </dependency>
        <!-- 连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.7</version>
        </dependency>
        <!-- 日志
         slf4j 接口               logback 是实现
         commons-logging 接口     桥接 - slf4j
        -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
        <!-- 日志桥接 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>1.7.25</version>
        </dependency>

        <!-- 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

    2）在 spring.xml 配置文件中

    <!-- 1) 读取properties中的内容-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 2) 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${drivername}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${password}"/>
        <property name="maxActive" value="${max}"/>
        <property name="minIdle" value="${min}"/>
    </bean>

    <!-- 3) 获取 SqlSessionFactory 工厂类-->
    <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 4) 搜索有哪些 mapper 实现类，把mapper接口自动配置成 spring 中的 <bean>-->
    <bean id="scannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">

        <!-- name="basePackage":(起始)包名, 从这个包开始扫描-->
        <property name="basePackage" value="com.chen.mapper"/>

    </bean>

   3）编写 mapper接口

public interface ProductMapper {

    /**
     * 增
     */
    @Insert("insert into product(name,price) values(#{name},#{price})")
    void insert(Product product);

    /**
     * 删
     */
    @Delete("delete from product where id=#{id}")
    void delete(int id);

    /**
     * 改
     */
    @Update("update product set name=#{name},price=#{price} where id=#{id}")
    void update(Product product);

    /**
     * 查: 根据id查
     */
    @Select("select id,name,price from product where id=#{id}")
    Product findById(int id);

    /**
     * 分页查询(物理分页)
     */
    @Select("select id,name,price from product limit #{start},#{size}")
    List<Product> findByPage(Map map);

    /**
     * 分页查询（逻辑分页）
     */
    @Select("select id, name,price from product")
    List<Product> PageLogical(RowBounds rowBounds);

    /**
     *  当 *.java -> *.class时，方法的参数名信息会丢失，所以再按m名称去找，则无法找到该参数名
     *  mybatis的mapper映射中，默认方法最多只接收一个参数, 多个参数需要用map或list等集合包装
     *  要突破这个限制需要使用@Param注解，把它加在方法参数上，建立方法参数和sql中#{}之间的联系：
     * @param m
     * @param n
     * @return
     */
    @Select("select id, name,price from product limit #{start},#{size}")
    List<Product> Page(@Param("start")int m,@Param("size")int n);

    /**
     * 动态sql，配合 XXXMapper.xml 映射文件进行 动态sql拼接
     *  注意： 1) 目录结构要一致
     *         2) xml中 namespace的取值与接口的包名类名要一致
     *         3) 接口中的方法名与xml中标签id对应
     *         4) 接口中的方法名不能重复（不支持重载）
     */
    void deleteByIds(List<Integer> ids);
}

     4）使用 XXXMapper.xml  配合 Mapper接口 进行 动态 SQL 的拼接

<mapper namespace="com.chen.mapper.ProductMapper">

    <!-- id名必须和ProductMapper接口中的方法名保持一致-->
    <delete id="deleteByIds" parameterType="list" >
        delete from product where id in
        <foreach collection="list" item="i" open="("  separator="," close=")">
            #{i}
        </foreach>
    </delete>

</mapper>

      5) 测试Mapper接口

public class MapperTest {
    //获得spring容器
    static ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

    @Test
    public void test1(){
        // 利用反射，得到spring自动配置的 ProductMapper 的 <bean>
        ProductMapper mapper = context.getBean(ProductMapper.class);
        Product p = new Product();
        p.setName("kobe");
        p.setPrice(6666.66);
        mapper.insert(p);
    }
}

 

Spring中的声明式事务管理： transcation  –>  tx (简写)

   1）配置信息中引入事务的命名空间

 xmlns:tx="http://www.springframework.org/schema/tx"
 http://www.springframework.org/schema/tx
 http://www.springframework.org/schema/tx/spring-tx.xsd

  2）启用事务：用注解驱动的方式来管理事务

            <tx:annotation-driven/>

  3）在 spring.xml 中配置事务管理器 : id=” transcationManager ” 

     <!-- 5）配置事务管理器
         id="transactionManager" id名必须是transactionManager，不能更改
     -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

  4) 在要使用事务的方法或类上，添加注解 @Transcational，spring会自动提交，回滚事务

 /**
     事务注解(@Transactional)：
              加在方法上，表示此方法受事务管理(自动提交，回滚事务)
              加在类上，那么这个类中的所有方法都受事务管理

 
     最后要注意的是，在业务方法中不要自己try-catch捕获异常，否则spring无法自动回滚事务
 */
    @Transactional
    public void business1(){
        productMapper.delete(100000005);
        productMapper.delete(100000006);
        int i = 1/0;
        productMapper.delete(100000007);

    }

 

@Transcational 的工作原理：

              默认情况下，数据库处于自动提交模式，每一条语句处于一个单独的事务中，在这条语句执行完毕时，如果执行成功则隐式的提交事务，如果执行失败则隐式的回滚事务。
             事务管理，是一组相关的操作处于一个事务之中，因此必须关闭数据库的自动提交模式。这点，Spring会在org/springframework/jdbc/datasource/DataSourceTransactionManager.java中将底层连接的自动提交特性设置为false

注解 @Transcational:

 

  1.     @Transcational                                                                                                                                                                默认情况下，只有方法出现的 是RuntimeException或Error以及它们的子类时（未检查异常），才会导致事务回滚       如果要改变默认情况
                       @Transactional(rollbackFor=异常类.class)
                             那么方法如果出现了该异常，或该异常的子类异常时，就会回滚                                                                               @Transactional(noRollbackFor=异常类.class)
                             当遇到这种异常时，不会回滚事务
        ***注意***：在业务方法中不要自己try-catch捕获异常，否则spring无法自动回滚事务                                                        
  2.   @Transactional(readOnly = true|false) ：true表示只读（只有查询） false（会有增删改）
        设置为true，性能会有所提升，但是底层数据库驱动支持(对mysql支持)                                                                                   
  3.    事务超时设置:
           @Transactional(timeout=30) //默认是30秒                                                                                                                                  
  4.   事务的传播行为： @Transcational (propagation=传播行为)                                                                                                 只有两个业务类的方法相互调用时，传播行为才会有效
                     ProductService 商品业务类
                               @Transactional(propagation=REQUIRED) 
                                biz1() { // 事务1
                                           biz2()；
                                }
                     OrderService   订单业务类    
                              @Transactional(propagation=REQUIRES_NEW)
                               biz2(); // 事务2
    事务传播行为 说明
    @Transactional(propagation=Propagation.REQUIRED) 如果有事务， 那么加入事务， 没有的话新建一个(默认情况)
    @Transactional(propagation=Propagation.NOT_SUPPORTED) 容器不为这个方法开启事务
    @Transactional(propagation=Propagation.REQUIRES_NEW) 不管是否存在事务，都创建一个新的事务，原来的挂起，新的执行完毕，继续执行老的事务
    @Transactional(propagation=Propagation.MANDATORY) 必须在一个已有的事务中执行，否则抛出异常
    @Transactional(propagation=Propagation.NEVER) 必须在一个没有的事务中执行，否则抛出异常(与Propagation.MANDATORY相反)
    @Transactional(propagation=Propagation.SUPPORTS) 如果其他bean调用这个方法，在其他bean中声明事务，那就用事务。如果其他bean没有声明事务，那就不用事务 
  5.   事务隔离级别： @Transcational( isolation = ” 事务的隔离级别 “) 

事务隔离级别

说明

@Transactional(isolation = Isolation.READ_UNCOMMITTED)

读取未提交数据(会出现脏读， 不可重复读)，基本不使用

@Transactional(isolation = Isolation.READ_COMMITTED)(SQLSERVER默认)

读取已提交数据(会出现不可重复读和幻读)

@Transactional(isolation = Isolation.REPEATABLE_READ)

可重复读(会出现幻读)

@Transactional(isolation = Isolation.SERIALIZABLE)

串行化
  • 脏读 : 一个事务读取到另一事务未提交的更新数据
  • 不可重复读 : 在同一事务中， 多次读取同一数据返回的结果有所不同， 换句话说， 后续读取可以读到另一事务已提交的更新数据。
  • 可重复读：在同一事务中多次读取数据时，能够保证所读数据一样，也就是后续读取不能读到另一事务已提交的更新数据
  • 幻读 : 一个事务读到另一个事务已提交的insert数据                                                                                    

 

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/131409.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0


相关推荐

  • FileStream常用的属性和方法：

    FileStream常用的属性和方法：

    FileStream常用的属性和方法：对流进行操作时要引用usingSystem.IO;命名空间FileStream常用的属性和方法：属性：CanRead判断当前流是否支持读取，返回bool值，True表示可以读取CanWrite判断当前流是否支持写入，返回bool值，True表示可以写入方法：Read()从流中读取数据，返回字节数组Write()将字节块（字节数组）写入该流Seek…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年7月24日
  • NumPy 文件存取 tofile，fromfile， load，save

    NumPy 文件存取 tofile，fromfile， load，save

    NumPy 文件存取 tofile，fromfile， load，save

    全栈程序员-用户IM 全栈程序员-用户IM
    2020年11月8日
  • murmurhash3 java_MurMurHash3

    murmurhash3 java_MurMurHash3

    murmurhash3 java_MurMurHash3packageutil.hash;/***TheMurmurHash3algorithmwascreatedbyAustinApplebyandplacedinthepublicdomain.*ThisjavaportwasauthoredbyYonikSeeleyandalsoplacedintothepublicdomain.*…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年10月19日
  • kafka和rabbitmq和activemq区别_kafka消息持久化处理

    kafka和rabbitmq和activemq区别_kafka消息持久化处理

    kafka和rabbitmq和activemq区别_kafka消息持久化处理一、语言不同RabbitMQ是由内在高并发的erlanng语言开发，用在实时的对可靠性要求比较高的消息传递上。kafka是采用Scala语言开发，它主要用于处理活跃的流式数据,大数据量的数据处理上二、结构不同RabbitMQ采用AMQP（AdvancedMessageQueuingProtocol，高级消息队列协议）是一个进程间传递异步消息的网络协议RabbitMQ…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年10月28日
  • Python 获取时间戳_python精确到毫秒时间戳

    Python 获取时间戳_python精确到毫秒时间戳

    Python 获取时间戳_python精确到毫秒时间戳python获取当前时间戳的方法：1、使用time模块，语法为“time.time()”；2、使用datetime模块，语法为“datetime.datetime.now().timestamp()”。使用模块timeimporttimenow=time.time()print(now)1593580247.232345使用模块datetime模块datetime提供了以更面向对象的方式操作…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年10月2日
  • 前端开发必备站点汇总

    前端开发必备站点汇总

    常用前端手册：http://caniuse.com/http://www.w3school.com.cn/http://www.runoob.com/http://www.css88.com/

    全栈程序员-用户IM 全栈程序员-用户IM
    2021年12月28日

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号