【Java WEB】MyBatis详解

个人博客：www.hellocode.top
⭐所有文章均在上方博客首发，其他平台同步更新
本文专栏：《Java Web从入门到实战》
> 如没有Java基础，请先前往《Java零基础指南》专栏学习相应知识
⚡如有问题，欢迎指正，一起学习~~

---

---

快速入门

框架是一款半成品软件，我们可以基于这个半成品软件继续开发，来完成我们的个性化需求

• ORM(Object Relational Mapping)：对象关系映射
  指的是持久化数据和实体对象的映射模式，为了解决面向对象与关系型数据库存在的互不匹配的现象的技术

MyBatis介绍

• 原始 JDBC 的操作问题分析
  1. 频繁创建和销毁数据库的连接会造成系统资源浪费从而影响系统性能
  2. sql 语句在代码中硬编码，如果要修改sql语句，就需要修改 java 代码，造成代码不易维护
  3. 查询操作时，需要手动将结果集中的数据封装到实体对象中
  4. 增删改查操作需要参数时，需要手动将实体对象的数据设置到sql 语句的占位符
• 原始 JDBC 的操作问题解决方案
  1. 使用数据库连接池初始化连接资源
  2. 将sql 语句抽取到配置文件中
  3. 使用反射、内省等底层操作技术，将实体与表进行属性与字段的自动映射
• MyBatis 是一个优秀的基于Java的持久层框架，它内部封装了 JDBC，使开发者只需要关注 SQL 语句本身，而不需要花费精力去处理加载驱动、创建连接、创建执行者等复杂的操作
• MyBatis 通过xml 或注解的方式将要执行的各种 Statement 配置起来，并通过Java 对象和Statement 中 SQL 的动态参数进行映射生成最终要执行的SQL语句
• 最后 MyBatis 框架执行完SQL 并将结果映射为 Java对象并返回。采用 ORM 思想解决了实体和数据库映射的问题，对 JDBC 进行了封装，屏蔽了 JDBC API 底层访问细节，使我们不用与 JDBC API 打交道，就可以完成对数据库的持久化操作
• MyBatis官网：http://www.mybatis.org

入门程序

1. 数据库数据准备

2. 导入 jar 包

3. 在src 下创建映射配置文件

   
   DOCTYPE mapper
           PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
           "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   <mapper namespace="StudentMapper">
       <select id="selectAll" resultType="mybaits.study.bean.Student">
           SELECT * FROM student
       select>
   mapper>
   

4. 在 src 下创建核心配置文件

   
   DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
   
   <configuration>
       <environments default="mysql">
           <environment id="mysql">
               <transactionManager type="JDBC">transactionManager>
               <dataSource type="POOLED">
                   <property name="driver" value="com.mysql.jdbc.Driver"/>
                   <property name="url" value="jdbc:mysql://192.168.23.129:3306/db1"/>
                   <property name="username" value="root"/>
                   <property name="password" value="密码"/>
               dataSource>
           environment>
       environments>
       
       <mappers>
           <mapper resource="StudentMapper.xml">mapper>
       mappers>
   configuration>
   

5. 编写测试类完成相关API 的使用

6. 运行测试查看结果

package mybatis.study.dao;

import mybatis.study.bean.Student;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class StudentTest01 {
    /*
    *       查询全部
    * */
    @Test
    public void selectAll() throws IOException {
        // 1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        // 2. 获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        // 3.通过SqlSession工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 4.执行映射配置文件中的sql语句，并接收结果
        List<Student> list = sqlSession.selectList("StudentMapper.selectAll");

        // 5.处理结果
        for(Student stu : list){
            System.out.println(stu);
        }

        // 6.释放资源
        sqlSession.close();
        is.close();
    }
}

---

相关API

Resources

• org.apache.ibaties.io.Resources：加载资源的工具类
• 核心方法

  返回值	方法名	说明
  InputStream	getResourcesAsStream(String fileName)	通过类加载器返回指定资源的字节输入流

  除了使用这个工具类的方法，还可以使用类名.class.getClassLoader().getResourceAsStream(配置文件名.xml)获取到字节输入流对象

SqlSessionFactoryBuilder

• org.apache.ibaties.session.SqlSessionFactoryBuilder：获取SqlSessionFactory 工厂对象的功能类
• 核心方法

  返回值	方法名	说明
  SqlSessionFactory	build(InputStream is)	通过指定资源字节输入流获取SqlSession 工厂对象

SqlSessionFactory

• org.apache.ibaties.srssion.SqlSessionFactory：获取SqlSession 构建者对象的工厂接口
• 核心方法

  返回值	方法名	说明
  SqlSession	openSession()	获取SqlSession 构建者对象，并开启手动提交事务
  SqlSession	openSession(boolean autoCommit)	获取SqlSession构建者对象，如果参数为true，则开启自动提交事务

SqlSession

• org.apache.ibaties.session.SqlSession：构建者对象接口。用于执行SQL、管理事务、接口代理
• 核心方法

  返回值	方法名	说明
  List	selectList(String statement,Object paramter)	执行查询语句，返回List集合
  T	selectOne(String statement,Object paramter)	执行查询语句，返回一个结果对象
  int	insert(String statement,Object paramter)	执行新增语句，返回影响行数
  int	update(String statement,Object paramter)	执行修改语句，返回影响行数
  int	delete(String statement,Object paramter)	执行删除语句，返回影响行数
  void	commit()	提交事务
  void	rollback()	回滚事务
  T	getMapper(Classcls)	获取指定接口的代理实现类对象
  void	close()	释放资源

---

映射配置文件

• 映射配置文件包含了数据和对象之间的映射关系以及要执行的SQL语句

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="StudentMapper">
    
    <select id="selectAll" resultType="mybaits.study.bean.Student">
        SELECT * FROM student
    select>
mapper>

查询功能

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="StudentMapper">
    <select id="selectAll" resultType="mybatis.study.bean.Student">
        SELECT * FROM student
    select>
    <select id="selectById" resultType="mybatis.study.bean.Student" parameterType="java.lang.Integer">
        SELECT * FROM student WHERE id = #{参数名称}
    select>
mapper>

@Test 
public void selectById() throws IOException {
    InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    SqlSession sqlSession = sqlSessionFactory.openSession();
    Student stu = sqlSession.selectOne("StudentMapper.selectById", 1);
    System.out.println(stu);
    sqlSession.close();
    is.close();
}

• ：查询功能标签
  属性
  id：唯一标识
  parameterType：指定参数映射的对象类型
  resultType：指定结果映射的对象类型
  SQL 获取参数
  #{属性名}

  注意：属性名要和对象中的成员变量名称一致，才能获取到正确的值

  新增功能

  <insert id="insert" parameterType="mybatis.study.bean.Student">
  	INSERT INTO student VALUES (#{id},#{name},#{age})
  insert>
  

  @Test
  public void insert() throws IOException {
      InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
      SqlSession sqlSession = sqlSessionFactory.openSession(true);
      Student stu = new Student(7,"老八",28);
      int result = sqlSession.insert("StudentMapper.insert", stu);
      // 如果没有开启自动提交事务，对于增删改，在执行完SQL后还需要提交事务
      // sqlSession.commit();
      System.out.println(result);
      is.close();
      sqlSession.close();
  }
  

  • ：新增功能标签
  • 属性
    id：唯一标识，配合名称空间使用
    parameterType：指定参数映射的对象类型
    resultType：指定结果映射的对象类型

    对于增删改操作，返回的的结果都是int类型的影响行数，故resultType可以省略不写

  • SQL获取参数
    #{属性名}

    注意：属性名要和对象中的成员变量名称一致，才能获取到正确的值

  修改功能

  <update id="update" parameterType="mybatis.study.bean.Student">
  	UPDATE student SET name = #{name},age = #{age} WHERE id = #{id}
  update>
  

  @Test
  public void update() throws IOException {
      InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
      SqlSession sqlSession = sqlSessionFactory.openSession();
      Student stu = new Student(6,"周七七",37);
      int result = sqlSession.insert("StudentMapper.update", stu);
      // 如果没有开启自动提交事务，对于增删改，在执行完SQL后还需要提交事务
      sqlSession.commit();
      System.out.println(result);
      is.close();
      sqlSession.close();
  }
  

  • ：修改功能标签
  • 属性
    id：唯一标识，配合名称空间使用
    parameterType：指定参数映射的对象类型
    resultType：指定结果映射的对象类型
  • SQL 获取参数
    #{属性名}

  删除功能

  <delete id="delete" parameterType="java.lang.Integer">
  	DELETE FROM student WHERE id = #{id}
  delete>
  

  @Test
  public void delete() throws IOException {
      InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
      SqlSession sqlSession = sqlSessionFactory.openSession();
      int result = sqlSession.delete("StudentMapper.delete", 7);
      System.out.println(result);
      // 提交事务
      sqlSession.commit();
      sqlSession.close();
      is.close();
  }
  

  • ：删除功能标签
  • 属性
    id：唯一标识，配合名称空间使用
    parameterType：指定参数映射的对象类型
    resultType：指定结果映射的对象类型
  • SQL 获取参数
    #{属性名}

  ---

  核心配置文件

  • 核心配置文件包含了MyBatis 最核心的设置和属性信息。如数据库的连接、事务、连接池信息等

  
  
  DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
  
  
  <configuration>
      
      <environments default="mysql">
          
          <environment id="mysql">
              
              <transactionManager type="JDBC">transactionManager>
              
              <dataSource type="POOLED">
                  
                  <property name="driver" value="com.mysql.jdbc.Driver"/>
                  <property name="url" value="jdbc:mysql://192.168.23.129:3306/db1"/>
                  <property name="username" value="root"/>
                  <property name="password" value="lh18391794828"/>
              dataSource>
          environment>
      environments>
      
      <mappers>
          
          <mapper resource="StudentMapper.xml">mapper>
      mappers>
  configuration>
  

  数据库连接配置文件引用

  • 为了方便修改，可以将核心配置文件中的数据库连接信息抽取出来：jdbc.properties

    driver=com.mysql.jdbc.Driver
    url=jdbc:mysql://192.168.23.129
    username=root
    password=密码
    

  • ：使用该标签可以引入数据库连接配置文件
  • 属性
    resource：数据库连接配置文件路径
  • 获取数据库连接参数
    ${键名}

  
  DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
  
  <configuration>
      
      <properties resource="jdbc.properties">properties>
      <environments default="mysql">
          <environment id="mysql">
              <transactionManager type="JDBC">transactionManager>
              <dataSource type="POOLED">
                  
                  <property name="driver" value="${driver}"/>
                  <property name="url" value="${url}"/>
                  <property name="username" value="${username}"/>
                  <property name="password" value="${password}"/>
              dataSource>
          environment>
      environments>
      <mappers>
          <mapper resource="StudentMapper.xml">mapper>
      mappers>
  configuration>
  

  起别名

  • ：为全类名起别名的父标签
  • ：为全类名起别名的子标签
  • 属性
    type：指定全类名
    alias：指定别名
  • ：为指定包下所有的类起别名的子标签（别名就是类名）

  
  <typeAliases>
  	<typeAlias type="mybatis.study.bean.Student" alias="Student">typeAlias>
      
  typeAliases>
  

  在核心配置文件中起别名后，就可以简化映射配置文件中的全类名

  MyBatis自带的一些别名

  别名	数据类型
  string	java.lang.String
  long	java.lang.Long
  int	java.lang.Integer
  double	java.lang.Double
  boolean	java.lang.Boolean
  …	…

  ---

  Dao层的实现

  传统方式

  • 分层思想：控制层（controller）、业务层（service）、持久层（dao）
  • 调用流程
    控制层 --> 业务层 --> 持久层 --> DB

    在MyBatis中，持久层叫mapper

  package mybatis.study.mapper;
  
  import mybatis.study.bean.Student;
  
  import java.util.List;
  
  /*
  *       持久层
  * */
  
  
  public interface StudentMapper {
      // 查询全部
      public abstract List<Student> selectAll();
  
      // 根据id查询
      public abstract Student selectById(Integer id);
  
      // 新增数据
      public abstract Integer insert(Student stu);
  
      // 修改数据
      public abstract Integer update(Student stu);
  
      // 删除数据
      public abstract Integer delete(Integer id);
  }
  

  package mybatis.study.mapper.impl;
  
  import mybatis.study.bean.Student;
  import mybatis.study.mapper.StudentMapper;
  import org.apache.ibatis.io.Resources;
  import org.apache.ibatis.session.SqlSession;
  import org.apache.ibatis.session.SqlSessionFactory;
  import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.List;
  
  public class StudentMapperImpl implements StudentMapper {
      @Override
      public List<Student> selectAll() {
          InputStream is = null;
          SqlSession sqlSession = null;
          List<Student> list = null;
          try{
              is = Resources.getResourceAsStream("MyBatisConfig.xml");
              SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
              sqlSession = sqlSessionFactory.openSession(true);
              list = sqlSession.selectList("StudentMapper.selectAll");
          }catch (Exception e){
              e.printStackTrace();
          }finally {
              if(is != null){
                  try {
                      is.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              if(sqlSession != null){
                  sqlSession.close();
              }
          }
          return list;
      }
  
      @Override
      public Student selectById(Integer id) {
          InputStream is = null;
          SqlSession sqlSession = null;
          Student stu = null;
          try{
              is = Resources.getResourceAsStream("MyBatisConfig.xml");
              SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
              sqlSession = sqlSessionFactory.openSession(true);
              stu = sqlSession.selectOne("StudentMapper.selectById",id);
          }catch (Exception e){
              e.printStackTrace();
          }finally {
              if(is != null){
                  try {
                      is.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              if(sqlSession != null){
                  sqlSession.close();
              }
          }
          return stu;
      }
  
      @Override
      public Integer insert(Student stu) {
          InputStream is = null;
          SqlSession sqlSession = null;
          Integer result = null;
          try{
              is = Resources.getResourceAsStream("MyBatisConfig.xml");
              SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
              sqlSession = sqlSessionFactory.openSession(true);
              result = sqlSession.insert("StudentMapper.insert",stu);
          }catch (Exception e){
              e.printStackTrace();
          }finally {
              if(is != null){
                  try {
                      is.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              if(sqlSession != null){
                  sqlSession.close();
              }
          }
          return result;
      }
  
      @Override
      public Integer update(Student stu) {
          InputStream is = null;
          SqlSession sqlSession = null;
          Integer result = null;
          try{
              is = Resources.getResourceAsStream("MyBatisConfig.xml");
              SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
              sqlSession = sqlSessionFactory.openSession(true);
              result = sqlSession.update("StudentMapper.update",stu);
          }catch (Exception e){
              e.printStackTrace();
          }finally {
              if(is != null){
                  try {
                      is.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              if(sqlSession != null){
                  sqlSession.close();
              }
          }
          return result;
      }
  
      @Override
      public Integer delete(Integer id) {
          InputStream is = null;
          SqlSession sqlSession = null;
          Integer result = null;
          try{
              is = Resources.getResourceAsStream("MyBatisConfig.xml");
              SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
              sqlSession = sqlSessionFactory.openSession(true);
              result = sqlSession.delete("StudentMapper.delete",id);
          }catch (Exception e){
              e.printStackTrace();
          }finally {
              if(is != null){
                  try {
                      is.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              if(sqlSession != null){
                  sqlSession.close();
              }
          }
          return result;
      }
  }
  

  package mybatis.study.service;
  
  import mybatis.study.bean.Student;
  
  import java.util.List;
  
  /*
  *       业务层
  * */
  
  public interface StudentService {
      // 查询全部
      public abstract List<Student> selectAll();
  
      // 根据id查询
      public abstract Student selectById(Integer id);
  
      // 新增数据
      public abstract Integer insert(Student stu);
  
      // 修改数据
      public abstract Integer update(Student stu);
  
      // 删除数据
      public abstract Integer delete(Integer id);
  }
  

  package mybatis.study.service.impl;
  
  import mybatis.study.bean.Student;
  import mybatis.study.mapper.StudentMapper;
  import mybatis.study.mapper.impl.StudentMapperImpl;
  import mybatis.study.service.StudentService;
  
  import java.util.List;
  
  public class StudentServiceImpl implements StudentService {
      // 创建持久层对象
      private StudentMapper mapper = new StudentMapperImpl();
  
      @Override
      public List<Student> selectAll() {
          return mapper.selectAll();
      }
  
      @Override
      public Student selectById(Integer id) {
          return mapper.selectById(id);
      }
  
      @Override
      public Integer insert(Student stu) {
          return mapper.insert(stu);
      }
  
      @Override
      public Integer update(Student stu) {
          return mapper.update(stu);
      }
  
      @Override
      public Integer delete(Integer id) {
          return mapper.delete(id);
      }
  }
  

  package mybatis.study.controller;
  
  import mybatis.study.bean.Student;
  import mybatis.study.service.StudentService;
  import mybatis.study.service.impl.StudentServiceImpl;
  import org.junit.Test;
  
  import java.util.List;
  
  /*
  *   控制层测试类
  * */
  public class StudentController {
      // 创建业务层对象
      private StudentService service = new StudentServiceImpl();
  
      @Test
      public void selectAll(){
          List<Student> stus = service.selectAll();
          for(Student stu : stus){
              System.out.println(stu);
          }
      }
  
      @Test
      public void selectById(){
          Student stu = service.selectById(5);
          System.out.println(stu);
      }
  
      @Test
      public void insert(){
          Student stu = new Student(5,"赵六",46);
          Integer result = service.insert(stu);
          System.out.println(result);
      }
  
      @Test
      public void delete(){
          Integer result = service.delete(5);
          System.out.println(result);
      }
  
      @Test
      public void update(){
          Student stu = new Student(5,"赵六六",36);
          Integer result = service.update(stu);
          System.out.println(result);
      }
  }
  

  LOG4J

  • 在日常开发过程中，排查问题时难免需要输出 MyBatis 真正执行的 SQL语句、参数、结果等信息，我们就可以借助 LOG4J 的功能来实现执行信息的输出
  • 使用步骤
    1. 导入jar 包
    2. 修改核心配置文件

       
       <settings>
       	<setting name="logImpl" value="log4j"/>
       settings>
       

    3. 在 src下编写LOG4J 配置文件

       # Global logging configuration
       # 输出信息的显示。四个级别：ERROR、WARN、INFO、DEBUG
       log4j.rootLogger=DEBUG, stdout
       # Console output...
       log4j.appender.stdout=org.apache.log4j.ConsoleAppender
       log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
       log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n
       

  接口代理方式

  传统方式实现Dao层，我们既需要写接口，还要写实现类。而MyBatis 框架可以帮助我们省略编写 Dao层接口实现类的步骤。程序员只需要编写接口，由MyBatis 框架根据接口的定义来创建该接口的动态代理对象

  实现规则

  1. 映射配置文件中的名称空间必须和 Dao 层接口的全类名相同
  2. 映射配置文件中的增删改查标签的id属性必须和Dao层接口的方法名相同
  3. 映射配置文件中的增删改查标签的 parameterType 属性必须和 Dao层 接口方法的参数相同
  4. 映射配置文件中的增删改查标签的resultType 属性必须和 Dao层 接口方法的返回值相同

  代码实现

  1. 删除mapper层接口的实现类
  2. 修改映射配置文件
  3. 修改service 层接口的实现类，采用接口代理方式实现功能

   
   
   DOCTYPE mapper
           PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
           "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   <mapper namespace="mybatis.study.mapper.StudentMapper">
       <select id="selectAll" resultType="Student">
           SELECT * FROM student
       select>
       <select id="selectById" resultType="Student" parameterType="int">
           SELECT * FROM student WHERE id = #{id}
       select>
       <insert id="insert" parameterType="Student">
           INSERT INTO student VALUES (#{id},#{name},#{age})
       insert>
       <update id="update" parameterType="Student">
           UPDATE student SET name = #{name},age = #{age} WHERE id = #{id}
       update>
       <delete id="delete" parameterType="int">
           DELETE FROM student WHERE id = #{id}
       delete>
   mapper>
  

   @Override
   public List<Student> selectAll() {
       InputStream is = null;
       List<Student> list = null;
       SqlSession sqlSession = null;
       try{
           // 1.加载核心配置文件
           is = Resources.getResourceAsStream("MyBatisConfig.xml");
           // 2. 获取SqlSessionFactory 工厂对象
           SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
           // 3. 获取SqlSession对象
           sqlSession = sqlSessionFactory.openSession(true);
           // 4.获取StudentMapper持久层接口的实现类对象
           StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
           // 5.通过实现类对象调用方法，接收结果
           list = mapper.selectAll();
       }catch (Exception e){
           e.printStackTrace();
       }finally {
           // 6.释放资源
           if(sqlSession != null){
               sqlSession.close();
           }
           if(is != null){
               try {
                   is.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
       }
       return list;
   }
  

  通过动态代理开发模式，我们只编写一个接口，不写实现类，我们通过 getMapper()方法最终获取到org.apache.ibatis.binding.MapperProxy 代理对象，然后执行功能，而这个代理对象正是 MyBatis 使用了 JDK 的动态代理技术，帮助我们生成了代理实现类对象，从而可以进行相关持久化操作

  动态代理实现类对象在执行方法的时候最终调用了 mapperMethod.execute() 方法，这个方法中通过 switch语句根据操作类型来判断是新增、修改、删除、查询操作，最后一步回到了 MyBatis 最原生的 SqlSession 方式来执行增删改查

  ---

  动态sql

  • MyBatis 映射配置文件中，前面使用的SQL 都是比较简单的，有些时候业务逻辑复杂时，我们的 SQL就是动态变化的，此时前面学习的 SQL 就不能满足需求了
  • 多条件查询
    SELECT * FROM student WHERE id = ? AND name = ? AND age = ?
SELECT * FROM student WHERE id = ? AND name = ?
  • 动态SQL 标签
    ：条件判断标签
    ：循环遍历标签

  if标签

  • ：条件标签。如果有动态条件，则使用该标签代替where 关键字
  • ：条件判断标签

    <if test="条件判断">
        查询条件拼接
    if>
    

  <select id="selectCondition" resultType="student" parameterType="student">
      SELECT * FROM student
      <where>
          <if test="id != null">
              id = #{id}
          if>
          <if test="name != null">
              AND name = #{name}
          if>
          <if test="age != null">
              AND age = #{age}
          if>
      where>
  select>
  

  foreach标签

  • ：循环遍历标签。适用于多个参数或者的关系

    <foreach collection = "" open = "" close = "" item = "" separator = "">
        获取参数
    foreach>
    

  • 属性
    collection：参数容器类型，（list-集合，array-数组）
    open：开始的 SQL 语句
    close：结束的 SQL 语句
    item：参数变量名
    separator：分隔符

  <select id="selectByIds" resultType="Student" parameterType="list">
      SELECT * FROM student
      <where>
          <foreach collection="list" open="id IN (" close=")" item="id" separator=",">
              #{id}
          foreach>
      where>
  select>
  

  SQL 片段的抽取

  • 我们可以将一些重复性的SQL 语句进行抽取，以达到复用的效果
  • ：抽取SQL语句标签
    抽取的SQL语句
  • ：引入SQL片段标签
    

  <sql id="select">SELECT * FROM studentsql>
  
  <select id="selectAll" resultType="Student">
      <include refid="select" />
  select>
  <select id="selectById" resultType="Student" parameterType="int">
      <include refid="select" /> WHERE id = #{id}
  select>
  

  ---

  分页插件

  • 分页可以将很多条结果进行分页显示
  • 如果当前在第一页，则没有上一页。如果在最后一页，则没有下一页
  • 需要明确当前是第几页，这一页中显示多少条结果

  在企业级的开发中，分页也是一种常见的技术。而目前使用的 MyBatis 是不带分页功能的，如果想实现分页的功能，需要我们手动编写 LIMIT 语句。但是不同的数据库实现分页的 SQL 语句也是不同的，所以手写分页成本较高。这个时候可以借助分页插件来帮助我们实现分页功能

  • PageHelper：第三方分页助手。将复杂的分页操作进行封装，从而让分页功能变得非常简单

  分页插件实现步骤

  1. 导入jar 包：pagehelper-5.1.10.jar jsqlparser-3.1.jar
  2. 在核心配置文件中集成分页助手插件
  3. 在测试类中使用分页助手相关 API 实现分页功能

  
  <plugins>
      <plugin interceptor="com.github.pagehelper.PageInterceptor">plugin>
  plugins>
  

  分页参数的获取

  • PageInfo：封装分页相关参数的功能类
  • 核心方法

    返回值	方法名	说明
    long	getTotal()	获取总条数
    int	getPages()	获取总页数
    int	getPageNum()	获取当前页
    int	getPageSize()	获取每页显示条数
    int	getPrePage()	获取上一页
    int	getNextPage()	获取下一页
    boolean	isIsFirstPage()	获取是否是第一页
    boolean	isIsLastPage()	获取是否是最后一页

  @Test
  public void selectPaging() throws IOException {
      InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
      SqlSession sqlSession = sqlSessionFactory.openSession(true);
      StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
  
      // 通过分页助手实现分页功能
      // 参数：当前页,显示的条数
      PageHelper.startPage(1,3);
  
      List<Student> list = mapper.selectAll();
      for(Student stu : students){
          System.out.println(stu);
      }
  
      //获取分页相关参数
      PageInfo<Student> info = new PageInfo<>(list);
      
      System.out.println("总条数" + info.getTotal());
      System.out.println("总页数" + info.getPages());
      System.out.println("当前页" + info.getPageNum());
      System.out.println("每页条数" + info.getPageSize());
      System.out.println("上一页" + info.getPrePage());
      System.out.println("下一页" + info.getNextPage());
      System.out.println("是否是第一页：" + info.isIsFirstPage());
      System.out.println("是否是最后一页：" + info.isIsLastPage());
  
      sqlSession.close();
      is.close();
  }
  

  ---

  多表操作

  • 我们之前学习的都是基于单表操作的，二实际开发中，随着业务逻辑难度的加深，肯定需要多表操作的
  • 多表模型的分类
    • 一对一：在任意一方建立外键，关联对方的主键
    • 一对多：在多的一方建立外键，关联少的一方的主键
    • 多对多：借助中间表，中间表至少两个字段，分别关联两张表的主键

  一对一

  • 一对一模型：人和身份证，是一对一的关系
  • 数据准备

    CREATE DATABASE db12;
    USE db12;
    CREATE TABLE person(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	NAME VARCHAR(20),
    	age INT
    );
    INSERT INTO person VALUES (NULL,'张三',23),(NULL,'李四',24),(NULL,'王五',25);
    CREATE TABLE card(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	number VARCHAR(30),
    	pid INT,
    	CONSTRAINT cp_fk FOREIGN KEY (pid) REFERENCES person(id)
    );
    INSERT INTO card VALUES (NULL,'12345',1),(NULL,'23456',2),(NULL,'34567',3);
    

  • 映射配置文件

    
    DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="mybatis.study.table01.OneToOneMapper">
        
        <resultMap id="oneToOne" type="card">
            <id column="cid" property="id" />
            <result column="number" property="number" />
            
            <association property="p" javaType="person">
                <id column="pid" property="id" />
                <result column="name" property="name" />
                <result column="age" property="age" />
            association>
        resultMap>
        <select id="selectAll" resultMap="oneToOne">
            SELECT c.id,number,pid,NAME,age FROM card c,person p WHERE c.pid = p.id;
        select>
    mapper>
    

    @Test
    public void selectAll() throws IOException {
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        OneToOneMapper mapper = sqlSession.getMapper(OneToOneMapper.class);
        List<Card> list = mapper.selectAll();
        for(Card card : list){
            System.out.println(card);
        }
    }
    

  • ：配置字段和对象属性的映射关系标签
    id属性：唯一标识
    type属性：实体对象类型
  • ：配置主键映射关系标签
  • ：配置非主键映射关系标签
    column属性：表中字段名称
    property属性：实体对象变量名称
  • ：配置被包含对象的映射关系标签
    property属性：被包含对象的变量名
    javaType属性：被包含对象的数据类型

  一对多

  • 一对多模型：班级和学生，一个班级可以有多个学生
  • 数据准备

    CREATE TABLE classes(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	NAME VARCHAR(20)
    );
    INSERT INTO classes VALUES (NULL,'一班'), (NULL,'二班');
    CREATE TABLE student(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	NAME VARCHAR(30),
    	age INT,
    	cid INT,
    	CONSTRAINT cs_fk FOREIGN KEY (cid) REFERENCES classes(id)
    );
    INSERT INTO student VALUES (NULL,'张三',23,1),(NULL,'李四',24,1),(NULL,'王五',25,2),(NULL,'赵六',26,2);
    

  • 映射配置文件

    
    DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="mybatis.study.table02.OneToManyMapper">
        <resultMap id="oneToMany" type="classes">
            <id column="cid" property="id" />
            <result column="cname" property="name" />
            
            
            <collection property="students" ofType="student">
                <id column="sid" property="id" />
                <result column="sname" property="name" />
                <result column="sage" property="age" />
            collection>
            
        resultMap>
        <select id="selectAll" resultMap="oneToMany">
            SELECT c.id cid,c.name cname,s.id sid, s.name sname,s.age sage FROM classes c,student s WHERE c.id = s.cid;
        select>
    mapper>
    

  @Test
      public void selectAll() throws IOException {
          InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
          SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
          SqlSession sqlSession = sqlSessionFactory.openSession(true);
          OneToManyMapper mapper = sqlSession.getMapper(OneToManyMapper.class);
          List<Classes> classes = mapper.selectAll();
          for(Classes cls : classes){
              System.out.println(cls.getId() + "," + cls.getName());
              List<Student> students = cls.getStudents();
              for(Student stu : students){
                  System.out.println("\t" + stu);
              }
          }
      }
  

  • ：配置字段和对象属性的映射关系标签
    id属性：唯一标识
    type属性：实体对象类型
  • ：配置主键映射的关系标签
  • ：配置非主键映射关系标签
    column属性：表中字段名称
    property属性：实体对象变量名称
  • ：配置被包含集合对象的映射关系标签
    property属性：被包含集合对象的变量名
    ofType属性：集合中保存的对象数据类型

  多对多

  • 多对多模型：学生和课程，一个学生可以选择多门课程，一个课程也可以被多个学生所选择
  • 数据准备

    CREATE TABLE course(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	NAME VARCHAR(20)
    );
    INSERT INTO course VALUES (NULL,'语文'),(NULL,'数学');
    CREATE TABLE stu_cr(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	sid INT,
    	cid INT,
    	CONSTRAINT sc_fk1 FOREIGN KEY (sid) REFERENCES student(id),
    	CONSTRAINT sc_fk2 FOREIGN KEY (cid) REFERENCES course(id)
    );
    INSERT INTO stu_cr VALUES (NULL,1,1),(NULL,1,2),(NULL,2,1),(NULL,2,2);
    

  • 映射配置文件

    
    DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="mybatis.study.table03.ManyToManyMapper">
        <resultMap id="manyToMany" type="student">
            <id column="sid" property="id" />
            <result column="sname" property="name" />
            <result column="sage" property="age" />
            
            <collection property="courses" ofType="course">
                <id column="cid" property="id" />
                <result column="cname" property="name" />
            collection>
        resultMap>
        
        <select id="selectAll" resultMap="manyToMany">
            SELECT sc.sid,s.name sname,s.age sage,sc.cid,c.name cname FROM student s,course c,stu_cr sc WHERE sc.sid = s.id AND sc.cid = c.id;
        select>
    mapper>
    

  @Test
  public void selectAll() throws IOException {
      InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
      SqlSession sqlSession = sqlSessionFactory.openSession(true);
      ManyToManyMapper mapper = sqlSession.getMapper(ManyToManyMapper.class);
      List<Student> students = mapper.selectAll();
      for(Student stu : students){
          System.out.println(stu.getId() + "," + stu.getName() + "," + stu.getAge());
          List<Course> courses = stu.getCourses();
          for(Course cour : courses){
              System.out.println("\t" + cour);
          }
      }
  }
  

  • ：配置字段和对象属性的映射关系标签
    id属性：唯一标识
    type属性：实体对象类型
  • ：配置主键映射关系标签
  • ：配置非主键映射关系标签
    column属性：表中字段名称
    property属性：实体对象变量名称
  • ：配置被包含集合对象的映射关系标签
    property属性：被包含集合对象的变量名
    ofType属性：集合中保存的对象数据类型

  ---

  注解开发

  • 我们除了使用映射配置文件来操作以外，还可以使用注解形式来操作
  • 常用注解
    @Select("查询的SQL语句")：执行查询操作注解
    @Insert("新增的SQL语句")：执行新增操作注解
    @Update("修改的SQL语句")：执行修改操作注解
    @Delete("删除的SQL语句")：执行删除操作注解

  查询操作

  1. 创建接口和查询方法
  2. 在核心配置文件中配置映射关系

     <mappers>
         
     	<package name="mybatis.study.mapper" />
     mappers>
     

  3. 编写测试类

     @Test
     public void selectAll() throws IOException {
         InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
         SqlSession sqlSession = sqlSessionFactory.openSession(true);
         StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
         List<Student> students = mapper.selectAll();
         for (Student student : students) {
             System.out.println(student);
         }
     }
     

  新增操作

  1. 在接口中创建新增方法

     // 新增操作
     @Insert("INSERT INTO student VALUES (#{id},#{name},#{age})")
     public abstract Integer insert(Student stu);
     

  2. 编写测试类
  3. 实现功能

     @Test
     public void insert() throws IOException {
         InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
         SqlSession sqlSession = sqlSessionFactory.openSession(true);
         StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
         Student stu = new Student(null,"周七",27);
         Integer result = mapper.insert(stu);
         System.out.println(result);
     }
     

  修改、删除操作原理相同

  ---

  注解多表操作

  一对一

  // 查询全部
  @Select("SELECT * FROM card")
  @Results(
      {
          @Result(column = "id", property = "id"),
          @Result(column = "number", property = "number"),
          @Result(
              property = "p",     //被包含对象的变量名
              javaType = Person.class,     //被包含对象的实际数据类型
              column = "pid",         // 根据查询出的card表中的pid查询person表
              // one、@One 是一对一操作的固定写法
              // select属性：指定调用哪个接口中的哪个方法
              one=@One(select = "mybatis.study.one_to_one.PersonMapper.selectById")
          )
      }
  )
  public abstract List<Card> selectAll();
  

  // 根据id查询
  @Select("SELECT * FROM student WHERE id = #{id}")
  public abstract Person selectById(Integer id);
  

  • @Results：封装映射关系的父注解
    Result[] value()：定义了Result数组
  • @Result：封装映射关系的子注解
    column属性：查询出表中的字段名称
    property属性：实体对象中的属性名
    javaType属性：被包含对象的数据类型
    one属性：一对一查询的固定属性
  • @One：一对一查询的注解
    select属性：指定调用某个接口中的方法

  一对多

  // 查询全部
  @Select("SELECT * FROM classes")
  @Results({
      @Result(column = "id",property = "id"),
      @Result(column = "name",property = "name"),
      @Result(
          property = "students",
          javaType = List.class,
          column = "id",
          /*
          *       many、@Many 一对多查询的固定写法
          *       select：指定调用哪个接口中的哪个查询方法
          * */
          many=@Many(select = "mybatis.study.one_to_many.StudentMapper.selectByCid")
      )
  })
  public abstract List<Classes> selectAll();
  

  //根据cid查询student表
  @Select("SELECT * FROM student WHERE cid = #{cid}")
  public abstract List<Student> selectByCid(Integer cid);
  

  • many属性：一对多查询的固定属性
  • @Many：一对多查询的注解
    select属性：指定调用某个接口中的方法

  多对多

  // 查询全部
  @Select("SELECT DISTINCT s.id,s.name,s.age FROM student s,stu_cr sc WHERE sc.sid=s.id")
  @Results({
      @Result(column = "id",property = "id"),
      @Result(column = "name",property = "name"),
      @Result(column = "age",property = "age"),
      @Result(
          property = "courses",
          javaType= List.class,
          column = "id",
          many = @Many(select = "mybatis.study.many_to_many.CourseMapper.selectBySid")
      )
  })
  public abstract List<Student> selectAll();
  

  // 根据学生id查询所选课程
  @Select("SELECT c.id,c.name FROM stu_cr sc,course c WHERE sc.cid=c.id AND sc.sid = #{id}")
  public abstract List<Course> selectBySid(Integer id);
  

  多对多中的一些注解和一对多一样，主要区别就是多对多中使用了第三张中间表

  ---

  构建SQL

  • 我们之前通过注解开发时，相关SQL语句都是自己直接拼写的。一些关键字写起来比较麻烦，而且容易出错
  • MyBatis 给我们提供了 org.apache.ibatis.jdbc.SQL 功能类，专门用于构建 SQL语句

  方法名	说明
  SELECT(String…column)	根据字段拼接查询语句
  FROM(String…table)	根据表名拼接语句
  WHERE(String…condition)	根据条件拼接语句
  INSERT_INTO(String table)	根据表名拼接新增语句
  VALUES(String column,String values)	根据字段和值拼接插入数据语句
  UPDATE(String table)	根据表名拼接修改语句
  DELETE_FROM(String table)	根据表名拼接删除语句
  … …	… …

  查询操作

  • 定义功能类并提供获取查询的SQL 语句的方法
  • @SelectProvider：生成查询用的 SQL语句注解
    type属性：生成SQL 语句功能类对象
    method属性：指定调用方法

  public static String getSql(){
      String sql = new SQL(){
          {
              SELECT("*");
              FROM("student");
          }
      }.toString();
      return sql;
  }
  

  // 查询全部
  // @Select("SELECT * FROM student")
  @SelectProvider(type = ReturnSql.class, method = "getSelectAll")
  public abstract List<Student> selectAll();
  

  新增操作

  • 定义功能类并提供获取新增SQL语句的方法
  • @InsertProvider：生成新增用的SQL语句注解
    type属性：生成SQL语句功能类对象
    method属性：指定调用方法

  // 定义方法，返回新增的sql语句
  public String getInsert(Student stu){
      return new SQL(){
          {
              INSERT_INTO("student");
              INTO_VALUES("#{id},#{name},#{age}");
          }
      }.toString();
  }
  

  // 新增操作
  // @Insert("INSERT INTO student VALUES (#{id},#{name},#{age})")
  @InsertProvider(type = ReturnSql.class,method = "getInsert")
  public abstract Integer insert(Student stu);
  

  修改操作

  • 定义功能类并提供获取修改SQL语句的方法
  • @UpdateProvider：生成修改用的 SQL语句注解
    type属性：生成SQL 语句功能类对象
    method属性：指定调用方法

  // 定义方法，返回修改的SQL语句
  public String getUpdate(Student stu){
      return new SQL(){
          {
              UPDATE("student");
              SET("name=#{name}","age=#{age}");
              WHERE("id=#{id}");
          }
      }.toString();
  }
  

  // 修改操作
  //@Update("UPDATE student SET name=#{name},age=#{age} WHERE id = #{id}")
  @UpdateProvider(type = ReturnSql.class,method = "getUpdate")
  public abstract Integer update(Student stu);
  

  删除操作

  • 定义功能类并提供获取删除的 SQL语句的方法
  • @DeleteProvider：生成删除用的SQL语句注解
    type属性：生成SQL 语句功能类对象
    method属性：指定调用方法

  // 定义方法，返回删除的sql语句
  public String getDelete(Integer id){
      return new SQL(){
          {
              DELETE_FROM("student");
              WHERE("id=#{id}");
          }
      }.toString();
  }
  

  // 删除操作
  //@Delete("DELETE FROM student WHERE id = #{id}")
  @DeleteProvider(type = ReturnSql.class,method = "getDelete")
  public abstract Integer delete(Integer id);
  

  ---

  推荐阅读：【JavaWEB】JavaScript基础

  你可能感兴趣的:(Java,WEB从入门到实战,java,后端,开发语言,MyBatis,mysql)

  • 40岁的java程序员，还有出路吗？ cesske java开发语言
    目录前言一、现状与挑战二、出路与机遇三、案例分析与启示四、结语前言40岁Java程序员的出路：挑战与机遇并存在科技日新月异的今天，IT行业始终保持着高速的发展态势，而Java作为其中的重要一员，其地位依然稳固且充满挑战。对于一位40岁的Java程序员而言，面对职业生涯的“中年危机”，是否还有出路？本文将从多个维度探讨这一问题，旨在为这一群体提供思考和启示。一、现状与挑战职场竞争加剧随着技术的不断发
  • 你在更新什么？ 余衿笙
    我在想，为什么现在好多了解到的东西更新得那么快？两三天前听到的流行歌，过几天就忘了，因为有新的流行歌代替;对上一个小鲜肉的了解还停留在他的名字和作品上，新的面孔就又出现了，人气不断高涨。好像我所了解的东西不去“更新”，不追上社会变化的步伐，就显得自己多落伍，随时会遭人鄙夷似的。但事实上，其实大可不必如此。一方面，我想，环境对个人的影响是确实存在的，时间久了必定会有随之变化的端倪。快节奏的生活，不断
  • 做事一定要认真 地上的垚
    大脑突然被惊醒，我猛然起身，接着发了下呆，灵魂回归后意识到：啊，今天上班要迟到了！我按了按手机发现手机已关机，略微一看，原来是昨晚充电器没插上。一件微不足道的事折射出我的粗心大意，反映了我对待事情漠不关心，草草了事的态度。许许多多的事情都需要认认真真的对待才能做好，认真是自我努力的表现。工作中，我总是不停的犯错误，我谴责自己：连这点小事都要犯错，你有什么用啊。同时也安慰自己：不过是一点小错误而已，
  • 2019-03-19 Fiona_8bba
    春暖花开。上周二鼓励三年级孩子5点下了国际象棋课独自回家。开始是非常害怕，在校门口打了一个电话给爸爸，进门后又打给爸爸说到家了。经过鼓励，周四五点下了3D打印社团，又独立回家了。到周五，问他，你愿意去托管再上隔壁跆拳道还是自己回家，再去跆拳道？他说我愿意自己回家。周末正式和托管说不去了，把孩子的托管课时转入书法。昨天周一第一次3点放学就回家。嘱咐如下：第一步，进门就洗手。第二，按按钮烧水，烫奶。吃
  • sunxi-fel 的相关命令 蓝黑墨水 单片机
    文章目录简介常用命令说明获取flash的相关信息列出所有的FEL设备显示BROM信息烧写程序到内存烧写程序到flash简介这个命令是全志芯片的烧写程序。有很多写法。例如:F1C100S、F1C200S这个命令有很多隐藏的相关问题（这里不讨论）常用命令说明获取flash的相关信息$./sunxi-fel.exe-pspiflash-infoManufacturer:Winbond(EFh),mode
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架 叶准鑫Natalie
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
  • 【剽悍一只猫的剽悍行动营】不忘初心，砥砺前行 财务自由的社群运营人苏宝
    作者/梅子我在第15期剽悍行动营奇迹四连四排的同桌叫Tony。今天，我来讲一讲他的故事。Tony出生在湖北恩施的一个贫困的小山村，因为家里很穷，他很想通过自己的努力改变家庭的命运，所以他中途辍了学，过早的步入了社会。一开始的时候他也很迷茫，不知道到自己到底该干什么？能干什么？后来经同学介绍进入了一家鞋厂，从事搬运工作，开启了他人生中的第一次独立自主的打工之路。可是，现实与理想的差距，让他在鞋厂只干
  • Kubernetes部署MySQL数据持久化 沫殇-MS KubernetesMySQL数据库kubernetesmysql容器
    一、安装配置NFS服务端1、安装nfs-kernel-server：sudoapt-yinstallnfs-kernel-server2、服务端创建共享目录#列出所有可用块设备的信息lsblk#格式化磁盘sudomkfs-text4/dev/sdb#创建一个目录：sudomkdir-p/data/nfs/mysql#更改目录权限：sudochown-Rnobody:nogroup/data/nfs
  • 如何利用Samba跨平台分享Ubuntu文件夹 GottenZZP 部署相关ubuntulinux运维
    1.安装Samba终端输入sudoaptinstallsamba2.配置Samba终端输入sudovim/etc/samba/smb.conf打开配置文件滑动文件到最底下输入以下内容[Share]#要共享的文件夹路径path=/home/xxx/sambasharereadonly=nobrowsable=yes编辑完成后按一下Esc按键后输入:wq回车保存3.重启Samba服务终端输入sudos
  • MySQL事务隔离级别和MVCC 简书徐小耳
    MySQL事务隔离级别和MVCC参考：https://mp.weixin.qq.com/s/Jeg8656gGtkPteYWrG5_Nw1.MVCC只对读已提交和可重复的读有效果，而未提交读和串行则无意义。2.每条记录都会有trx_id(事务修改记录的id）和roll_pointer是一个指针指向旧版本的undo日志链表（row_id不是必必要的，如果有主键存在就不需要了）3.版本链的头结点就是记
  • JavaScript中秋快乐！ Q_w7742 javascript开发语言ecmascript
    我们来实现一个简单的祝福网页~主要的难度在于使用canvas绘图当点击canvas时候，跳出“中秋节快乐”字样，需要注册鼠标单击事件和计时器。首先定义主要函数：初始化当点击canvas之后转到onCanvasClick函数，绘图生成灯笼。functiononCanvasClick(){//事件处理函数context.clearRect(0,0,canvas1.width,canvas1.heigh
  • 家长会后的发言 2022-10-20 小听童之奶爸卓子
    每一次家长会，总有不少收获，既能从老师身上，也能从其她家长身上学到一些育儿知识。我原以为在大班下学期要为上小学做准备，现在看来，在大班这一年都要好上小学的心理和行动准备。幼小衔接，不是提前学习小学的内容，而是要为上小学做好孩子的各方面的能力准备，比如专注能力，幼儿园25分钟的课到小学就升级为40分钟的时间了。比如社会交往能力，上小学了，新环境，新面孔，能快速交到新朋友吗？比如语言能力，小学的老师没
  • Nginx从入门到实践(三) 听你讲故事啊
    动静分离动静分离是将网站静态资源（JavaScript，CSS，img等文件）与后台应用分开部署，提高用户访问静态代码的速度，降低对后台应用访问。动静分离的一种做法是将静态资源部署在nginx上，后台项目部署到应用服务器上，根据一定规则静态资源的请求全部请求nginx服务器，达到动静分离的目标。rewrite规则Rewrite规则常见正则表达式Rewrite主要的功能就是实现URL的重写，Ngin
  • 【人生感悟】真正厉害的人，抽象思维都很强大 加百力 生活工作感悟大数据科技数据分析
    我们都身处信息爆炸的时代，各种资讯蜂拥而至，很难保证所接收的信息都是准确的。在这样的情况下，拥有“穿透迷雾，直击核心”的能力非常关键。虽然钻研各个领域的专业知识可以帮助我们避免信息误导，但这个过程可能超出我们想象地漫长。事实上，真正厉害的人都有一个共同点——他们善于抽象思维。这也是我在读《科技群星闪耀时：15个创新传奇》这本书是意识到的。什么是抽象思维？抽象思维是一种超越细节、直指事物本质的思维方
  • 所谓睡眠卫生是什么？ 初几开门
    每个人天生都会对自己的身体产生好奇心，也会遇到一些困扰和问题，但常常缺乏科学的指导，尤其是那些羞于启齿的话题，更别提禁忌话题。可能好朋友和夫妻之间都无法就此坦诚相见，但不被提及，并不意味着会凭空消失。如果因此影响到正常的生活，更不能忽视，这个时候，有作者这样一个具备科学知识的知心大姐姐来答疑解惑，无疑会少走很多弯路，避免没必要的损失和伤害。看过本书的一些标题，有些人可能会想入非非，或者会讳疾忌医，
  • 个人学习笔记7-6：动手学深度学习pytorch版-李沐 浪子L 深度学习深度学习笔记计算机视觉python人工智能神经网络pytorch
    #人工智能##深度学习##语义分割##计算机视觉##神经网络#计算机视觉13.11全卷积网络全卷积网络（fullyconvolutionalnetwork，FCN）采用卷积神经网络实现了从图像像素到像素类别的变换。引入l转置卷积（transposedconvolution）实现的，输出的类别预测与输入图像在像素级别上具有一一对应关系：通道维的输出即该位置对应像素的类别预测。13.11.1构造模型下
  • 泰国之旅五 Ulrica一tf
    听，晨曦中，海鸟在叫我们起床喽！今天我们要去岛上游泳、潜水。早餐过后，我们坐快艇去岛上玩儿，大家把游泳衣都事先换好了，那快艇坐起来有点儿晕，颠簸的屁股都要裂开了，靠近大船的时候左右摇摆而且柴油味儿很大，所以第一站下来女儿和好朋友都感到不舒服了。P蔡拿了一瓶清凉的泰国青草药膏涂上了，又吃了一片晕船的含片，到后来才好。这一站是海上滑翔，团队里好多孩子都去玩了。大家玩的都很开心，除了有些卡屁股外，还是够
  • 设计模式】Listener模式和Visitor模式的区别 不爱洗脚的小滕 设计模式访问者模式javagolang
    文章目录前言一、介绍Listener模式Visitor模式二、代码实现2.1Listener模式的Java实现2.2Listener模式的Go实现2.3Visitor模式的Java实现2.4Visitor模式的Go实现三、总结前言在软件设计中，设计模式是解决特定问题的通用解决方案。Listener模式和Visitor模式是两种常见的行为设计模式，它们在不同的场景下提供了解决问题的有效方法。本文将详
  • 2022-07-06 榜一大哥啊
    非洲猪瘟检测流程要点1、进入实验室按照要求穿好装备进入实验室，病原稀释及制备，将实验用假阳性按照倍数稀释，最高稀释到一万倍。所有操作流程都在生物安全柜进行，按照流程进行编号，编写检测编号。在每个实验室都要将白大褂以及手套进行更换。2、到试剂准备区进行试剂准备，按照样品数量加阴阳对照进行配备，该项目在超净工作台进行。将制备好的试剂放入传递窗，进入核酸提取环节。3、核酸提取区，进行核酸提纯，用磁吸法核
  • Nginx的使用场景：构建高效、可扩展的Web架构 张某布响丸辣 nginx前端架构
    Nginx，作为当今最流行的Web服务器和反向代理软件之一，凭借其高性能、稳定性和灵活性，在众多Web项目中扮演着核心角色。无论是个人博客、中小型网站，还是大型企业级应用，Nginx都能提供强大的支持。本文将探讨Nginx的几个主要使用场景，帮助读者理解如何在实际项目中充分利用Nginx的优势。1.静态文件服务对于包含大量静态文件（如HTML、CSS、JavaScript、图片等）的网站，Ngin
  • 前端知识点 ZhangTao_zata 前端javascriptcss
    下面是一个最基本的html代码body{font-family:Arial,sans-serif;margin:20px;}//JavaScriptfunctionthatdisplaysanalertwhencalledfunctionshowMessage(){alert("Hello!Youclickedthebutton.");}MyFirstHTMLPageWelcometoMyPage
  • 2021-10-17(376) 刘玥上学记
    今天早上妈妈六点就把我喊起来了，天气太冷了，姥姥给我们煮了鸡蛋，路上保暖用一切按部就班的进行，到公司刚刚好七点五十妈妈给我安排的是上午两张试卷，下午两张试卷上午的没做完，下午的我实在是不想做了，后来凯丽姐姐说早点写完，可以早些玩耍我就回办公室写作业了一直到下午四点半，凯丽姐姐过来检查，数学卷子还没做完询问了半天，原来是乘法口诀没有背过，然后凯丽姐姐就一个一个的给我提问而且还说让我晚上回去自己再重新
  • 【nginx】ngx_http_proxy_connect_module 正向代理 等风来不如迎风去 网络服务入门与实战nginxhttp运维
    50.65无法访问服务器，(403错误)50.196可以访问服务器。那么，配置65通过196访问。需要一个nginx作为代理【nginx】搭配okhttp配置反向代理发送原生的nginx是不支持okhttp的CONNECT请求的。大神竟然给出了一个java工程GINX编译ngx_http_proxy_connect_module及做正向代理是linux构建的。是windows构建的：编译Windo
  • 后端开发刷题 | 把数字翻译成字符串（动态规划） jingling555 笔试题目动态规划java算法数据结构后端
    描述有一种将字母编码成数字的方式：'a'->1,'b->2',...,'z->26'。现在给一串数字，返回有多少种可能的译码结果数据范围：字符串长度满足0=10&&num<=26){if(i==1){dp[i]+=1;}else{dp[i]+=dp[i-2];}}}returndp[nums.length()-1];}}
  • 李笑来 6 你到底有没有资本+7什么是落后 盛大米
    6你到底有没有资本摘要不能够心平气和地被判上无期徒刑的资本，就别假装资本混迹江湖了。投资知识，经验，智慧，几乎只能从实战中获得————书上写的，牛人讲的，都跟你没关系，因为只有那些东西在你骨子里生根之后再发芽且不夭折而后还要等上很久才会茁壮甚至茂盛。。。。直接将年收入的10%-20%判死刑是最简单，最直接，最粗暴最有效的操作方式。投资，尤其是“好的投资”，一定是“舍我其谁”的活动。关于资本的思考，
  • 责任与平衡 wangjb_a9e9
    共修功课第十六天：婚姻是责任跟平衡，面对现实的问题，你是否承担起自己的责任，平衡到彼此之间的关系呢？引导：婚姻是一种责任跟平衡，与爱人与孩子之间的平衡。这里面有太多平衡，我们没有办法掌握，所以我们痛苦。从一个人的生活变成两个人生活要调整双方相处时间的平衡，同样道理，现在由两个人到有孩子的时候，那个平衡更难拿捏。自己愿意承担的责任，内心可以生发出力量。比如，陪孩子参加读书会，上辅导班。如果是别人给的
  • 第三十一节:Vue路由:前端路由vs后端路由的了解 曹老师
    1.认识前端路由和后端路由前端路由相对于后端路由而言的,在理解前端路由之前先对于路由有一个基本的了解路由:简而言之,就是把信息从原地址传输到目的地的活动对于我们来说路由就是:根据不同的url地址展示不同的页面内容1.1后端路由以前咱们接触比较多的后端路由,当改变url地址时,浏览器会向服务器发送请求,服务器根据这个url,返回不同的资源内容后端路由的特点就是前端每次跳转到不同url地址,都会重新访
  • 如何建设数据中台（五）——数据汇集—打破企业数据孤岛 weixin_47088026 学习记录和总结中台数据中台程序人生经验分享
    数据汇集——打破企业数据孤岛要构建企业级数据中台，第一步就是将企业内部各个业务系统的数据实现互通互联，打破数据孤岛，主要通过数据汇聚和交换来实现。企业采集的数据可以是线上采集、线下数据采集、互联网数据采集、内部数据采集等。线上数据采集主要载体分为互联网和移动互联网两种，对应有系统平台、网页、H5、小程序、App等，可以采用前端或后端埋点方式采集数据。线下数据采集主要是通过硬件来采集，例如：WiFi
  • CentOS7 安装MySQL5.7.44 不要Null了 javacentosmysql
    1.下载mysql安装包，我放在百度网盘里(下方链接)链接：https://pan.baidu.com/s/1_Mn1XW_1mWdTV4mhnLG66A提取码：s31n2.首先看看以前是否安装过mysqlrpm-qa|grep-imysql如果已经安装过mysql会提示卸载mysqlrpm-emysql-…3.使用FinallShell或者Xftp进行上传放到/usr/local/mysql，没
  • 非关系型数据库 天秤-white nosql
    一、为什么要用Nosql1.单机MySQL的时代。一个基本的网站访问量一般不会太大，单个数据库完全足够。那时候更多使用的静态网页html，服务器根本没有太大压力。这时候网站的瓶颈是什么？-数据量如果太大，一个机器放不下。-数据量太大需要建立数据的索引（B+Tree），一个服务器内存放不下。-访问量读写混合，一个服务器承受不了。2.memcached缓存+MySQL+垂直拆分（读写分离）。网站80%
  • 设计模式介绍 tntxia 设计模式
    设计模式来源于土木工程师 克里斯托弗 亚历山大（http://en.wikipedia.org/wiki/Christopher_Alexander）的早期作品。他经常发表一些作品，内容是总结他在解决设计问题方面的经验，以及这些知识与城市和建筑模式之间有何关联。有一天，亚历山大突然发现，重复使用这些模式可以让某些设计构造取得我们期望的最佳效果。 亚历山大与萨拉-石川佳纯和穆雷 西乐弗斯坦合作
  • android高级组件使用(一) 百合不是茶 androidRatingBarSpinner
    1、自动完成文本框（AutoCompleteTextView） AutoCompleteTextView从EditText派生出来，实际上也是一个文本编辑框，但它比普通编辑框多一个功能：当用户输入一个字符后，自动完成文本框会显示一个下拉菜单，供用户从中选择，当用户选择某个菜单项之后，AutoCompleteTextView按用户选择自动填写该文本框。 使用AutoCompleteTex
  • [网络与通讯]路由器市场大有潜力可挖掘 comsci 网络
              如果国内的电子厂商和计算机设备厂商觉得手机市场已经有点饱和了,那么可以考虑一下交换机和路由器市场的进入问题.....        这方面的技术和知识,目前处在一个开放型的状态,有利于各类小型电子企业进入  &nbs
  • 自写简单Redis内存统计shell 商人shang Linux shell统计Redis内存
    #!/bin/bash address="192.168.150.128:6666,192.168.150.128:6666" hosts=(${address//,/ }) sfile="staticts.log" for hostitem in ${hosts[@]} do ipport=(${hostitem
  • 单例模式(饿汉 vs懒汉) oloz 单例模式
    package 单例模式; /* * 应用场景:保证在整个应用之中某个对象的实例只有一个 * 单例模式种的《 懒汉模式》 * */ public class Singleton { //01 将构造方法私有化，外界就无法用new Singleton()的方式获得实例 private Singleton(){}; //02 申明类得唯一实例 priva
  • springMvc json支持 杨白白 json springmvc
    1.Spring mvc处理json需要使用jackson的类库，因此需要先引入jackson包 2在spring mvc中解析输入为json格式的数据:使用@RequestBody来设置输入 @RequestMapping("helloJson") public @ResponseBody JsonTest helloJson() {
  • android播放，掃描添加本地音頻文件 小桔子
            最近幾乎沒有什麽事情，繼續鼓搗我的小東西。想在項目中加入一個簡易的音樂播放器功能，就像華為p6桌面上那麼大小的音樂播放器。用過天天動聽或者QQ音樂播放器的人都知道，可已通過本地掃描添加歌曲。不知道他們是怎麼實現的，我覺得應該掃描設備上的所有文件，過濾出音頻文件，每個文件實例化為一個實體，記錄文件名、路徑、歌手、類型、大小等信息。具體算法思想，
  • oracle常用命令 aichenglong oracledba常用命令
    1 创建临时表空间 create temporary tablespace user_temp  tempfile 'D:\oracle\oradata\Oracle9i\user_temp.dbf' size 50m  autoextend on  next 50m maxsize 20480m  extent management local
  • 25个Eclipse插件 AILIKES eclipse插件
    提高代码质量的插件1. FindBugsFindBugs可以帮你找到Java代码中的bug，它使用Lesser GNU Public License的自由软件许可。2. CheckstyleCheckstyle插件可以集成到Eclipse IDE中去，能确保Java代码遵循标准代码样式。3. ECLemmaECLemma是一款拥有Eclipse Public License许可的免费工具，它提供了
  • Spring MVC拦截器+注解方式实现防止表单重复提交 baalwolf spring mvc
    原理：在新建页面中Session保存token随机码，当保存时验证，通过后删除，当再次点击保存时由于服务器端的Session中已经不存在了，所有无法验证通过。   1.新建注解：   ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
  • 《Javascript高级程序设计(第3版)》闭包理解 bijian1013 JavaScript
    “闭包是指有权访问另一个函数作用域中的变量的函数。”--《Javascript高级程序设计(第3版)》         看以下代码： <script type="text/javascript"> function outer() { var i = 10; return f
  • AngularJS Module类的方法 bijian1013 JavaScriptAngularJSModule
            AngularJS中的Module类负责定义应用如何启动，它还可以通过声明的方式定义应用中的各个片段。我们来看看它是如何实现这些功能的。 一.Main方法在哪里         如果你是从Java或者Python编程语言转过来的，那么你可能很想知道AngularJS里面的main方法在哪里？这个把所
  • [Maven学习笔记七]Maven插件和目标 bit1129 maven插件
    插件(plugin)和目标(goal) Maven，就其本质而言，是一个插件执行框架，Maven的每个目标的执行逻辑都是由插件来完成的，一个插件可以有1个或者几个目标，比如maven-compiler-plugin插件包含compile和testCompile，即maven-compiler-plugin提供了源代码编译和测试源代码编译的两个目标   使用插件和目标使得我们可以干预
  • 【Hadoop八】Yarn的资源调度策略 bit1129 hadoop
    1. Hadoop的三种调度策略 Hadoop提供了3中作业调用的策略， FIFO Scheduler Fair Scheduler Capacity Scheduler 以上三种调度算法，在Hadoop MR1中就引入了，在Yarn中对它们进行了改进和完善.Fair和Capacity Scheduler用于多用户共享的资源调度   2. 多用户资源共享的调度
  • Nginx使用Linux内存加速静态文件访问 ronin47
    Nginx是一个非常出色的静态资源web服务器。如果你嫌它还不够快，可以把放在磁盘中的文件，映射到内存中，减少高并发下的磁盘IO。 先做几个假设。nginx.conf中所配置站点的路径是/home/wwwroot/res，站点所对应文件原始存储路径：/opt/web/res shell脚本非常简单，思路就是拷贝资源文件到内存中，然后在把网站的静态文件链接指向到内存中即可。具体如下：
  • 关于Unity3D中的Shader的知识 brotherlamp unityunity资料unity教程unity视频unity自学
    首先先解释下Unity3D的Shader，Unity里面的Shaders是使用一种叫ShaderLab的语言编写的，它同微软的FX文件或者NVIDIA的CgFX有些类似。传统意义上的vertex shader和pixel shader还是使用标准的Cg/HLSL 编程语言编写的。因此Unity文档里面的Shader，都是指用ShaderLab编写的代码，然后我们来看下Unity3D自带的60多个S
  • CopyOnWriteArrayList vs ArrayList bylijinnan java
    package com.ljn.base; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.concurrent.CopyOnWriteArrayList; /** * 总述： * 1.ArrayListi不是线程安全的，CopyO
  • 内存中栈和堆的区别 chicony 内存
    1、内存分配方面：     堆：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式是类似于链表。可能用到的关键字如下：new、malloc、delete、free等等。     栈：由编译器(Compiler)自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中
  • 回答一位网友对Scala的提问 chenchao051 scalamap
    本来准备在私信里直接回复了，但是发现不太方便，就简要回答在这里。 问题 写道 对于scala的简洁十分佩服，但又觉得比较晦涩，例如一例，Map("a" -> List(11,111)).flatMap(_._2)，可否说下最后那个函数做了什么，真正在开发的时候也会如此简洁？谢谢    先回答一点，在实际使用中，Scala毫无疑问就是这么简单。
  • mysql 取每组前几条记录 daizj mysql分组最大值最小值每组三条记录
    一、对分组的记录取前N条记录：例如：取每组的前3条最大的记录 1.用子查询： SELECT * FROM tableName a  WHERE 3> (SELECT COUNT(*) FROM  tableName b WHERE b.id=a.id AND b.cnt>a. cnt) ORDER BY a.id,a.account DE
  • HTTP深入浅出 http请求 dcj3sjt126com http
      HTTP(HyperText Transfer Protocol)是一套计算机通过网络进行通信的规则。计算机专家设计出HTTP，使HTTP客户（如Web浏览器）能够从HTTP服务器(Web服务器)请求信息和服务，HTTP目前协议的版本是1.1.HTTP是一种无状态的协议，无状态是指Web浏览器和Web服务器之间不需要建立持久的连接，这意味着当一个客户端向服务器端发出请求，然后We
  • 判断MySQL记录是否存在方法比较 dcj3sjt126com mysql
    把数据写入到数据库的时，常常会碰到先要检测要插入的记录是否存在，然后决定是否要写入。 　　我这里总结了判断记录是否存在的常用方法： 　　sql语句： select   count ( * )  from  tablename; 　　然后读取count(*)的值判断记录是否存在。对于这种方法性能上有些浪费，我们只是想判断记录记录是否存在，没有必要全部都查出来。
  • 对HTML XML的一点认识 e200702084 htmlxml
    感谢http://www.w3school.com.cn提供的资料 HTML 文档中的每个成分都是一个节点。 节点 根据 DOM，HTML 文档中的每个成分都是一个节点。 DOM 是这样规定的： 整个文档是一个文档节点 每个 HTML 标签是一个元素节点 包含在 HTML 元素中的文本是文本节点 每一个 HTML 属性是一个属性节点 注释属于注释节点 Node 层次
  • jquery分页插件 genaiwei jqueryWeb前端分页插件
    //jquery页码控件// 创建一个闭包    (function($) {      // 插件的定义      $.fn.pageTool = function(options) {        var totalPa
  • Mybatis与Ibatis对照入门于学习 Josh_Persistence mybatisibatis区别联系
    一、为什么使用IBatis/Mybatis         对于从事 Java EE 的开发人员来说，iBatis 是一个再熟悉不过的持久层框架了，在 Hibernate、JPA 这样的一站式对象 / 关系映射（O/R Mapping）解决方案盛行之前，iBaits 基本是持久层框架的不二选择。即使在持久层框架层出不穷的今天，iBatis 凭借着易学易用、
  • C中怎样合理决定使用那种整数类型？ 秋风扫落叶 c数据类型
    如果需要大数值(大于32767或小于32767), 使用long 型。 否则, 如果空间很重要 (如有大数组或很多结构), 使用 short 型。 除此之外, 就使用 int 型。 如果严格定义的溢出特征很重要而负值无关紧要, 或者你希望在操作二进制位和字节时避免符号扩展的问题, 请使用对应的无符号类型。 但是, 要注意在表达式中混用有符号和无符号值的情况。    &nbs
  • maven问题 zhb8015 maven问题
      问题1： Eclipse 中 新建maven项目 无法添加src/main/java 问题    eclipse创建maevn web项目，在选择maven_archetype_web原型后，默认只有src/main/resources这个Source Floder。     按照maven目录结构，添加src/main/ja
  • (二)androidpn-server tomcat版源码解析之--push消息处理 spjich javaandrodipn推送
    在 (一)androidpn-server tomcat版源码解析之--项目启动这篇中，已经描述了整个推送服务器的启动过程，并且把握到了消息的入口即XmppIoHandler这个类，今天我将继续往下分析下面的核心代码，主要分为3大块，链接创建，消息的发送，链接关闭。 先贴一段XmppIoHandler的部分代码 /** * Invoked from an I/O proc
  • 用js中的formData类型解决ajax提交表单时文件不能被serialize方法序列化的问题 中华好儿孙 JavaScriptAjaxWeb上传文件FormData
    var formData = new FormData($("#inputFileForm")[0]); $.ajax({ type:'post', url:webRoot+"/electronicContractUrl/webapp/uploadfile", data:formData, async: false, ca
  • mybatis常用jdbcType数据类型 ysj5125094 mybatismapperjdbcType
      MyBatis 通过包含的jdbcType 类型 BIT         FLOAT      CHAR          
  按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
  首页 - 关于我们 - 站内搜索 - Sitemap - 侵权投诉

  版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.