h2coder
h2coder

MyBatis-Plus入门使用

Mybatis-Plus（MP）在 MyBatis 的基础上只做增强不做改变，简化开发、提高效率。

本篇是根据MyBatis-Plus入门教程视频，学习后总结的。有兴趣可以看一下，对于初学很有帮助。

课程是SpringBoot + MyBatis-Plus的方式集成的。

项目地址

文章可能描述的不清楚，或者你想看下代码，可以clone仓库

immoc-mybatis-plus

前置配置

数据库和表配置

本次学习，只用到1个库，一张表，库名为mp，表名为mp_user。直接拷贝到sql工具导入即可。

/*
 Navicat Premium Data Transfer

 Source Server         : mac
 Source Server Type    : MySQL
 Source Server Version : 50716
 Source Host           : localhost:3306
 Source Schema         : mp

 Target Server Type    : MySQL
 Target Server Version : 50716
 File Encoding         : 65001

 Date: 30/07/2020 23:12:46
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for mp_user
-- ----------------------------
DROP TABLE IF EXISTS `mp_user`;
CREATE TABLE `mp_user` (
  `id` bigint(20) NOT NULL COMMENT '主键',
  `name` varchar(30) DEFAULT NULL COMMENT '姓名',
  `age` int(11) DEFAULT NULL COMMENT '年龄',
  `email` varchar(50) DEFAULT NULL COMMENT '邮箱',
  `manager_id` bigint(20) DEFAULT NULL COMMENT '直属上级id',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  PRIMARY KEY (`id`),
  KEY `manager_fk` (`manager_id`),
  CONSTRAINT `manager_fk` FOREIGN KEY (`manager_id`) REFERENCES `mp_user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of mp_user
-- ----------------------------
BEGIN;
INSERT INTO `mp_user` VALUES (1087982257332887553, '大boss', 40, '[email protected]', NULL, '2019-01-11 14:20:20');
INSERT INTO `mp_user` VALUES (1088248166370832385, '王天风', 26, '[email protected]', 1087982257332887553, '2019-02-05 11:12:22');
INSERT INTO `mp_user` VALUES (1088250446457389058, '李艺伟', 32, '[email protected]', 1088248166370832385, '2019-02-14 08:31:16');
INSERT INTO `mp_user` VALUES (1094590409767661570, '张雨琪', 31, '[email protected]', 1088248166370832385, '2019-01-14 09:15:15');
INSERT INTO `mp_user` VALUES (1094592041087729666, '刘红雨', 32, '[email protected]', 1088248166370832385, '2019-01-14 09:48:16');
INSERT INTO `mp_user` VALUES (1288460195017072641, '刘明强', 31, NULL, 1088248166370832385, '2020-07-29 21:03:44');
INSERT INTO `mp_user` VALUES (1288842439342780417, '张强', 29, '[email protected]', 1088248166370832385, '2020-07-30 22:23:33');
INSERT INTO `mp_user` VALUES (1288848935841488897, '刘花', 29, '[email protected]', 1088248166370832385, '2020-07-30 22:48:27');
COMMIT;

SET FOREIGN_KEY_CHECKS = 1;

依赖配置

指定SpringBoot父工程

  1. 依赖SpringBootStarter
  2. lombok，生成get、set，减少模板代码
  3. MyBatis-Plus给我们提供的Starter
  4. 最后是mysql的驱动包。


    4.0.0

    com.immoc.mybatisplus
    immoc-mybatis-plus
    1.0-SNAPSHOT

    
        first
        crud
    
    pom

    
        UTF-8
        UTF-8
        1.8
        3.1.0
    

    
    
        org.springframework.boot
        spring-boot-starter-parent
        2.1.3.RELEASE
    

    
        
        
            org.springframework.boot
            spring-boot-starter
        
        
        
            org.springframework.boot
            spring-boot-starter-test
        
        
        
            org.projectlombok
            lombok
            true
        
        
        
            com.baomidou
            mybatis-plus-boot-starter
            ${mybatis.starter.version}
        
        
        
            mysql
            mysql-connector-java

数据库以及MyBaits-Plus的相关配置

在resource目录下，建立application.yml文件。配置：

  1. 项目名
  2. 数据库的4大配置，自行更改为自己mysql的用户名和密码！
  3. log打印级别
  4. MyBatis-Plus配置等，注释都写得很清楚了，就不在赘述了
spring:
  application:
    name: crud
  #配置数据库
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mp?useSSL=false&serverTimezone=GMT%2B8
    username: root
    password: hezihao123

#配置Log打印
logging:
  level:
    root: warn
    com.imooc.mybatisplus: trace
  pattern:
    console: '%p%m%n'

mybatis-plus:
  #配置mapper文件的位置，注意，如果你是maven多模块下使用，路径前需要加classpath*，即加载多个jar包下的xml文件
  mapper-locations:
    - classpath*:com/imooc/mybatisplus/mapper/*
  global-config:
    db-config:
      #全局id策略
      id-type: id_worker
      #字段生成sql的where策略，默认实体中的字段为null时，不添加到sql中，如果想为null，也添加到sql语句中，则使用ignored
      #一般不设置为ignored，因为在update语句中，如果不设置值，就会用null覆盖掉原有的值。一般我们是希望设置值的才更新，为null则不更新
      #not_empty，如果字段值为null或者空字符串，会忽略掉，不添加到sql语句中
      field-strategy: default
      #统一表名前缀
      #table-prefix: mp_
      #数据库表是否使用下划线间隔命名，默认为true
      table-underline: true
  #传统的mybatis配置文件位置
  #config-location: classpath:mybatis-config.xml
  #实体别名包配置
  type-aliases-package: com.imooc.mybatisplus.entity
  #注意configuration不能和config-location同时出现，不然会报错
  configuration:
    #驼峰转下划线（实体类用驼峰，数据库表字段用下划线），默认为true
    map-underscore-to-camel-case: true

配置原始MyBatis的配置文件

基本上MyBatis的配置都会配置到application.yml中，但有一些MyBatis的特有配置，还是可以放到原始的配置文件中的，例如二级、三级缓存等
在resources文件夹内创建mybatis-config.xml文件，暂时先不做配置。

配置MyBatis-Plus的分页插件

建立一个configuration包，增加MyBatisPlusConfig类，该类为一个配置类，提供PaginationInterceptor分页插件实例。

@Configuration
public class MyBatisPlusConfig {
    /**
     * MyBatisPlus的分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

应用入口

SpringBoot要求我们提供一个有main方法的入口，例如我们提供一个Application的类，用来启动

注意：要用@MapperScan注解，指定MyBatis扫描的包路径

@SpringBootApplication
//指定MyBatis扫描的包路径
@MapperScan("com.imooc.mybatisplus.dao")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

建立表对应的实体类

  1. @Data注解，生成实体类的get、set方法
  2. @EqualsAndHashCode注解，生成equals和hashcode方法，并指定不调用父类的equals和hashcode方法
  3. @TableName注解，指定实体类对应的表名，如果表名和实体类名一致，可以不加，但如果不一致，就需要该注解指定表名
  4. @TableId注解，指定实体类上成员变量为数据库表中的主键字段，value属性指定表中主键的名称。默认主键名为id，2个名字和数据库一致时，可以不加，不一致时需要加
  5. @TableField注解，表示成员变量为数据库对应的字段，如果成员变量和表字段的名称一致可以不加，如果不一致，就要加
    • value属性，用于指定对应的表字段名
    • strategy属性，可指定字段策略，默认当字段非null时，进行插入和更新操作，才会加入sql语句的数据字段中，可以配置多种策略，例如FieldStrategy.NOT_EMPTY，当字段为非null和非空字符串时，才加入sql语句
    • exist属性，标识该成员变量不是数据库表中字段，CRUD时，不会将该字段加入sql
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("mp_user")
public class User {
    /**
     * 主键
     * 注解@TableId，标识字段为主键，如变量名和数据库字段名不一致，可指定
     */
    //@TableId(value = "id")
    /**
     * 主键策略
     * 1.IdType.AUTO：数据库自增
     * 2.IdType.NONE：不配置，默认雪花算法
     * 以下3种策略，主键的Id不能设置值，才会生效
     * 3.IdType.ID_WORKER：雪花算法，数值类型
     * 4.IdType.UUID：UUID，字符串类型
     * 5.IdType.ID_WORKER_STR，雪花算法，字符串类型
     */
    @TableId(value = "id")
    private Long userId;
    /**
     * 姓名
     * 注解@TableField，标识为数据库字段，如变量名和数据库字段名不一致，可指定
     * condition属性，用作在使用实体作为查询条件给MyBatis-Plus直接查询时，可以指定字段是作为等值还是模糊查询，或不等于等条件（默认是等值）
     */
    //@TableField(value = "name", condition = SqlCondition.LIKE)
    /**
     * strategy属性，字段策略，NOT_EMPTY会忽略为null和空字符串的值
     */
    //@TableField(value = "name", strategy = FieldStrategy.NOT_EMPTY)
    @TableField(value = "name")
    private String readName;
    /**
     * 年龄
     */
    private Integer age;
    /**
     * 邮箱
     */
    private String email;
    /**
     * 直属上级
     */
    private Long managerId;
    /**
     * 创建时间
     */
    private LocalDateTime createTime;
    /**
     * 备注，非数据库字段，默认MyBatis-Plus会将实体的所有变量名作为数据库字段，如果没有字段就会报错
     * 标识为非数据库字段的3种方式：
     * 1.transient关键字，标识该字段不参与序列化
     * 2.将字段使用static静态标识，但会导致全类共用一个属性，一般不会用
     * 3.使用@TableField注解，将exist属性设置为false，来表示不是数据库字段
     */
    //private transient String remark;
    //private static String remark;
    @TableField(exist = false)
    private String remark;
}

配置Dao或者叫Mapper

UserMapper是User类对应的Mapper接口。每个自定义Mapper接口都继承BaseMapper接口，泛型指定操作的实体类。

BaseMapper中提供了很多单表操作，批量操作、条件查询、分页查询等，常用方法。
我们的自定义Mapper接口只写特殊的操作方法，例如自定义的多表联查等，现在暂时不加，后面讲解自定义方法时，再加。

public interface UserMapper extends BaseMapper {
}

测试CRUD

  • 插入测试，测试包下，新建InsertTest测试类

插入调用UserMapper的insert()方法，这是BaseMapper提供的。

//指定可以在Spring环境下使用Junit测试
@RunWith(SpringRunner.class)
//标识该类是SpringBoot测试类，并指定启动类
@SpringBootTest(classes = Application.class)
public class InsertTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void insert() {
        //插入
        User user = new User();
        user.setReadName("刘明强");
        user.setAge(31);
        user.setManagerId(1088248166370832385L);
        user.setCreateTime(LocalDateTime.now());
        int rows = userMapper.insert(user);
        System.out.println("影响记录数：" + rows);
    }

    @Test
    public void insert2() {
        //插入
        User user = new User();
        user.setReadName("向中");
        user.setAge(25);
        user.setManagerId(1088248166370832385L);
        user.setEmail("[email protected]");
        user.setCreateTime(LocalDateTime.now());
        user.setRemark("我是一个备注信息");
        int rows = userMapper.insert(user);
        System.out.println("影响记录数：" + rows);
    }
}
  • 删除测试，测试包下，新建DeleteTest测试类

删除方法，BaseMapper提供了好几种

  1. deleteById，根据主键进行删除
  2. deleteByMap，将删除条件放到Map中，进行删除
  3. deleteBatchIds，批量Id删除
  4. delete，传入Wrapper，Wrapper类是一个条件构造器，构造器中有or、get大于等条件添加方法。例如这里是删除年龄是27岁的，或者年龄大于41岁的记录
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class DeleteTest {
    @Autowired
    private UserMapper userMapper;

    /**
     * 根据主键Id删除
     */
    @Test
    public void deleteById() {
        int rows = userMapper.deleteById(1288677289033801729L);
        System.out.println("影响记录数：" + rows);
    }

    /**
     * 提供一个Map，Map中记录删除条件，进行删除
     */
    @Test
    public void deleteByMap() {
        HashMap columnMap = new HashMap<>();
        columnMap.put("id", 1288676754557825026L);
        columnMap.put("age", 25);
        int rows = userMapper.deleteByMap(columnMap);
        System.out.println("影响记录数：" + rows);
    }

    /**
     * 传入多个id，进行批量删除
     */
    @Test
    public void deleteIds() {
        int rows = userMapper.deleteBatchIds(Arrays.asList(1288461659789660161L,
                1288671248736870402L, 1288676285735272450L));
        System.out.println("影响记录数：" + rows);
    }

    /**
     * 使用条件构造器，进行删除
     */
    @Test
    public void deleteByWrapper() {
        LambdaQueryWrapper lambdaQuery = Wrappers.lambdaQuery();
        lambdaQuery.eq(User::getAge, 27)
                .or()
                .gt(User::getAge, 41);
        int rows = userMapper.delete(lambdaQuery);
        System.out.println("影响记录数：" + rows);
    }
}
  • 更新测试，测试包下，建立UpdateTest测试类

BaseMapper提供了如下更新方式：

  1. updateById，根据实体的主键Id进行更新
  2. update，传入实体和Wrapper类，实体设置更新后的值，Wrapper配置条件
  3. update，和第二种差不多，只是将Wrapper类构造时，传入实体类
  4. update，只用Wrapper，实体类传null，更新值用Wrapper的set方法设置
  5. update，和第四种一样，Wrapper类换成LambdaXXXWrapper，支持Lambda表达式
  6. update方法不在Mapper类中，而是在Wrapper构造时传入Mapper，调用Wrapper的update方法时，间接调用欧冠Mapper类
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class UpdateTest {
    @Autowired
    private UserMapper userMapper;

    /**
     * 更新条件和更新信息放在实体，按主键Id更新
     */
    @Test
    public void updateById() {
        User user = new User();
        user.setUserId(1088248166370832385L);
        user.setAge(26);
        user.setEmail("[email protected]");
        int rows = userMapper.updateById(user);
        System.out.println("影响记录数：" + rows);
    }

    /**
     * 更新信息放在实体，更新条件使用条件构造器，进行更新
     */
    @Test
    public void updateByWrapper() {
        UpdateWrapper updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("name", "李艺伟")
                .eq("age", 28);
        User user = new User();
        user.setEmail("[email protected]");
        user.setAge(29);
        int rows = userMapper.update(user, updateWrapper);
        System.out.println("影响记录数：" + rows);
    }

    /**
     * UpdateWrapper创建时传入更新实体
     */
    @Test
    public void updateByWrapper2() {
        User whereUser = new User();
        whereUser.setReadName("李艺伟");
        whereUser.setEmail("[email protected]");
        whereUser.setAge(29);
        UpdateWrapper updateWrapper = new UpdateWrapper<>(whereUser);
        int rows = userMapper.update(whereUser, updateWrapper);
        System.out.println("影响记录数：" + rows);
    }

    /**
     * 通过UpdateWrapper进行条件设置，并且通过set方法设置新值
     */
    @Test
    public void updateByWrapper3() {
        UpdateWrapper updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("name", "李艺伟")
                .eq("age", 29)
                .set("age", 30);
        int rows = userMapper.update(null, updateWrapper);
        System.out.println("影响记录数：" + rows);
    }

    /**
     * 通过UpdateWrapper进行条件设置，并且通过set方法设置新值
     */
    @Test
    public void updateByWrapperLambda() {
        LambdaUpdateWrapper updateWrapper = Wrappers.lambdaUpdate();
        updateWrapper.eq(User::getReadName, "李艺伟")
                .eq(User::getAge, 30)
                .set(User::getAge, 31);
        int rows = userMapper.update(null, updateWrapper);
        System.out.println("影响记录数：" + rows);
    }

    /**
     * 另外一种Lambda表达式方式
     */
    @Test
    public void updateByWrapperLambdaChain() {
        LambdaUpdateChainWrapper updateWrapper = new LambdaUpdateChainWrapper<>(userMapper);
        boolean isUpdateSuccess = updateWrapper.eq(User::getReadName, "李艺伟")
                .eq(User::getAge, 31)
                .set(User::getAge, 32)
                .update();
        System.out.println("是否更新成功：" + isUpdateSuccess);
    }
}
  • 查询测试，在测试包下，新增RetrieveTest测试类
  1. selectById，按主键Id查询
  2. selectBatchIds，批量Id查询
  3. selectByMap，查询条件放到Map中，进行查询
  4. selectList，提供QueryWrapper类实例，作为查询条件构造器使用
  5. selectMaps，提供QueryWrapper类实例，作为查询条件构造器使用，但返回的查询结果，List中不是实体类对象，而是一个Map，Map中存放着每一条属性和值
  6. selectObjs，提供QueryWrapper类实例，作为查询条件构造器使用，该方法只会拿出查询结果的第一列的属性和值返回（sql中是会查询其他字段的，但是selectObjs()方法只选择第一列的数据，只返回第一列的时候可以用它）
  7. selectCount，统计查询，统计查询结果，多少条记录
  8. selectOne，只查询出1条数据（必须查询结果只有1条，多条会报错）
  9. selectList，使用LambdaQueryWrapper，以使用Lambda表达式（好处：仿误写，如果是普通方式，传入数据库字段名，如果写错了就会报错，Lambda表达式使用方法引用来获取字段信息）
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class RetrieveTest {
    @Autowired
    private UserMapper userMapper;

    /**
     * 根据主键Id查询
     */
    @Test
    public void selectById() {
        User user = userMapper.selectById(1094590409767661570L);
        System.out.println(user);
    }

    /**
     * 一次使用多个Id进行查询
     */
    @Test
    public void selectIds() {
        List idList = Arrays.asList(1088248166370832385L, 1288460195017072641L, 1094590409767661570L);
        List userList = userMapper.selectBatchIds(idList);
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 使用Mao存放查询字段和条件来进行查询
     */
    @Test
    public void selectByMap() {
        //Map存放查询条件，注意key存放的是数据库的字段名，而不是实体中的变量名
        HashMap columnMap = new HashMap<>();
        columnMap.put("name", "王天风");
        columnMap.put("age", 25);
        List userList = userMapper.selectByMap(columnMap);
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 使用条件构造器进行查询
     * 

     * 需求：
     * 名字中包含"雨"，并且年龄小于40
     * sql: name like %雨% and age < 40
     */
    @Test
    public void selectByWrapper() {
        //直接创建一个条件构造器，获取使用Wrappers工具类
        QueryWrapper queryWrapper = new QueryWrapper<>();
        //QueryWrapper queryWrapper = Wrappers.query();
        queryWrapper
                //模糊查询，注意这里的字段都是数据库字段，而不是实体的变量名
                .like("name", "雨")
                //小于
                .lt("age", 40);
        List userList = userMapper.selectList(queryWrapper);
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 使用条件构造器进行查询
     * 

     * 需求：
     * 名字中包含"雨"，并且年龄大于等于20，且小于等于40，并且email不为空
     * sql: name like '%雨%' and age between 20 and 40 and email is not null
     */
    @Test
    public void selectByWrapper2() {
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper
                //模糊查询，注意这里的字段都是数据库字段，而不是实体的变量名
                .like("name", "雨")
                //年龄大于20，并且小于40
                .between("age", 20, 40)
                //不为null
                .isNotNull("email");
        List userList = userMapper.selectList(queryWrapper);
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 使用条件构造器进行查询
     * 

     * 需求：
     * 名字为王姓，或者年龄大于等于25，按照年龄降序排列，年龄相同按照id升序排列
     * name like '王%' or age>=25 order by age desc,id asc
     */
    @Test
    public void selectByWrapper3() {
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper
                //模糊查询，只包含右边一个%，注意这里的字段都是数据库字段，而不是实体的变量名
                .likeRight("name", "王")
                .or()
                //年龄大于等于25
                .ge("age", 25)
                //先按年龄降序排（从大到小）
                .orderByDesc("age")
                //年龄相同的，再按id的升序排（从小到大）
                .orderByAsc("id");
        List userList = userMapper.selectList(queryWrapper);
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 使用条件构造器进行查询
     * 

     * 创建日期为2019年2月14日，并且直属上级为名字为王姓
     * sql: date_format(create_time,'%Y-%m-%d')='2019-02-14' and manager_id in (select id from user where name like '王%')
     */
    @Test
    public void selectByWrapper4() {
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper
                //直接用，不使用占位符，可能会有sql注入的风险
                //.apply("date_format(create_time,'%Y-%m-%d')=2019-02-14")
                //apply占位符查询，目的是为了防止sql注入
                .apply("date_format(create_time,'%Y-%m-%d')={0}", "2019-02-14")
                //inSql子查询
                .inSql("manager_id", "select id from mp_user where name like '王%'");
        List userList = userMapper.selectList(queryWrapper);
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 使用条件构造器进行查询
     * 

     * 名字为王姓并且（年龄小于40或邮箱不为空）
     * sql: name like '王%' and (age<40 or email is not null)
     */
    @Test
    public void selectByWrapper5() {
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.likeRight("name", "王")
                //函数式编程
                //.and(wrapper-> wrapper.lt("age", 40).or().isNotNull("email"))
                .and(new Function, QueryWrapper>() {
                    @Override
                    public QueryWrapper apply(QueryWrapper wrapper) {
                        //年龄小于40
                        return wrapper.lt("age", 40)
                                //或者邮箱不为空
                                .or()
                                .isNotNull("email");
                    }
                });

        List userList = userMapper.selectList(queryWrapper);
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 使用条件构造器进行查询
     * 

     * 名字为王姓，或者（年龄小于40并且年龄大于20并且邮箱不为空）
     * sql: name like '王%' or (age<40 and age>20 and email is not null)
     */
    @Test
    public void selectByWrapper6() {
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper
                //王姓开头
                .likeRight("name", "王")
                //or()使用Function参数的，将获取年龄小于40，并且年龄大于20
                .or(wrapper -> wrapper.lt("age", 40)
                        .gt("age", 20)
                        //并且邮箱不为空的条件用括号包裹起来
                        .isNotNull("email"));
        List userList = userMapper.selectList(queryWrapper);
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 使用条件构造器进行查询
     * 

     * （年龄小于40或邮箱不为空）并且名字为王姓
     * sql: (age<40 or email is not null) and name like '王%'
     */
    @Test
    public void selectByWrapper7() {
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper
                //nested()，嵌套，就是加括号
                .nested(wrapper -> wrapper.lt("age", 40).or().isNotNull("email"))
                //邮箱不为null
                .likeRight("name", "王");
        List userList = userMapper.selectList(queryWrapper);
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 使用条件构造器进行查询
     * 

     * 年龄为30、31、34、35
     * sql: age in (30、31、34、35)
     */
    @Test
    public void selectByWrapper8() {
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper
                .in("age", Arrays.asList(30, 31, 34, 35));
        List userList = userMapper.selectList(queryWrapper);
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 使用条件构造器进行查询
     * 

     * 9、只返回满足条件的其中一条语句即可
     * sql: limit 1
     */
    @Test
    public void selectByWrapper9() {
        QueryWrapper queryWrapper = new QueryWrapper<>();
        //字符串拼接到sql，会有sql注入的风险
        queryWrapper.last("limit 1");
        List userList = userMapper.selectList(queryWrapper);
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 使用条件构造器进行查询
     * 

     * 需求：
     * select中字段不全部出现的查询，例如只查询出id和姓名（默认会查询出实体中的所有字段）
     * sql: select id,name from user where name like '%雨%' and age<40
     */
    @Test
    public void selectByWrapperSupper() {
        //直接创建一个条件构造器，获取使用Wrappers工具类
        QueryWrapper queryWrapper = new QueryWrapper<>();
        //QueryWrapper queryWrapper = Wrappers.query();
        queryWrapper
                //<重点>，相比上面的selectByWrapper，多了调用select()方法，传入需要查询的列名
                .select("id", "name")
                //模糊查询，注意这里的字段都是数据库字段，而不是实体的变量名
                .like("name", "雨")
                //小于
                .lt("age", 40);
        List userList = userMapper.selectList(queryWrapper);
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 使用条件构造器进行查询
     * 

     * 需求：
     * select中字段不全部出现的查询，例如只查询出id和姓名、年龄、邮箱（默认会查询出实体中的所有字段）
     * sql: select id,name,age,email from user where name like '%雨%' and age<40
     */
    @Test
    public void selectByWrapperSupper2() {
        //直接创建一个条件构造器，获取使用Wrappers工具类
        QueryWrapper queryWrapper = new QueryWrapper<>();
        //QueryWrapper queryWrapper = Wrappers.query();
        queryWrapper
                //模糊查询，注意这里的字段都是数据库字段，而不是实体的变量名
                .like("name", "雨")
                //小于
                .lt("age", 40)
                //如果字段比较多，我们每个都写上会比较麻烦，我们可以使用排除法，毕竟只是去掉少量的字段，其他字段都保留
                //参数一：实体类的Class
                //参数二：Predicate函数式接口，test()方法返回boolean，表示是否保留当前遍历到的字段，返回true代表需要，false代表不需要
                .select(User.class, info -> !info.getColumn().equals("create_time")
                        && !info.getColumn().equals("manager_id"));
        List userList = userMapper.selectList(queryWrapper);
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 测试动态条件
     */
    @Test
    public void testCondition() {
        String name = "王";
        String email = "";
        condition(name, email);
    }

    /**
     * 查询条件，条件可传可不传
     *
     * @param name  姓名
     * @param email 邮箱
     */
    private void condition(String name, String email) {
        QueryWrapper queryWrapper = new QueryWrapper<>();
        //手动判空后，加入条件
//        if (StringUtils.isNotEmpty(name)) {
//            queryWrapper.like("name", name);
//        }
//        if (StringUtils.isNotEmpty(email)) {
//            queryWrapper.like("email", email);
//        }
        //上面不够优雅，代码量大
        queryWrapper.like(StringUtils.isNotEmpty(name), "name", name)
                .like(StringUtils.isNotEmpty(email), "email", email);
        List userList = userMapper.selectList(queryWrapper);
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 使用实体Entity中的字段作为查询条件
     */
    @Test
    public void selectByWrapperEntity() {
        //使用实体作为查询条件加入到where中
        User whereUser = new User();
        whereUser.setReadName("刘雨红");
        whereUser.setAge(32);
        QueryWrapper queryWrapper = new QueryWrapper<>(whereUser);
        //再给查询条件加like等操作也是可以的
        queryWrapper
                .like("name", "雨")
                .lt("age", 40);
        List userList = userMapper.selectList(queryWrapper);
        for (User result : userList) {
            System.out.println(result);
        }
    }

    /**
     * 使用map作为sql的查询条件，map中的所有非空属性会作为sql的等于条件来拼接
     */
    @Test
    public void selectByWrapperAllEq() {
        QueryWrapper queryWrapper = new QueryWrapper<>();
        Map params = new HashMap<>();
        params.put("name", "王天风");
        //age参数，如果为null，会给生成的sql加上age is null，如果想过滤掉为null的属性字段，则将allEq的null2IsNull属性设置为false，默认为true
        params.put("age", null);
        //queryWrapper.allEq(params, false);

        //函数式方式，传入BiPredicate过滤器，test()方法返回当前遍历到的键值对是否加入到条件中，返回true表示加入条件中，返回false代表不加入到条件中
        queryWrapper.allEq(new BiPredicate() {
            @Override
            public boolean test(String key, Object value) {
                //例如过滤掉name的字段
                return !key.equals("name");
            }
        }, params);
        List userList = userMapper.selectList(queryWrapper);
        for (User result : userList) {
            System.out.println(result);
        }
    }

    /**
     * 查询，返回列表，但列表里面的元素不是实体，而是一个Map，每个Map就是一条记录的所有属性以键值对的形式存在
     * 当我们查询的字段相比实体字段少很多的时候，使用实体去存放，会有很多属性是null，不是很优雅，我们使用Map存放会更加明确有什么属性和值
     */
    @Test
    public void selectByWrapperMaps() {
        //直接创建一个条件构造器，获取使用Wrappers工具类
        QueryWrapper queryWrapper = new QueryWrapper<>();
        //QueryWrapper queryWrapper = Wrappers.query();
        queryWrapper
                .select("id", "name")
                //模糊查询，注意这里的字段都是数据库字段，而不是实体的变量名
                .like("name", "雨")
                //小于
                .lt("age", 40);
        List> userList = userMapper.selectMaps(queryWrapper);
        for (Map map : userList) {
            System.out.println(map);
        }
    }

    /**
     * 按照直属上级分组，查询每组的平均年龄、最大年龄、最小年龄。并且只取年龄总和小于500的组。
     * sql:
     * select avg(age) avg_age,min(age) min_age,max(age) max_age
     * from user
     * group by manager_id
     * having sum(age) <500
     */
    @Test
    public void selectByWrapperMaps2() {
        //直接创建一个条件构造器，获取使用Wrappers工具类
        QueryWrapper queryWrapper = new QueryWrapper<>();
        //QueryWrapper queryWrapper = Wrappers.query();
        queryWrapper
                //字段起别名：数据库字段名 别名
                .select("avg(age) avg_age", "min(age) min_age", "max(age) max_age")
                .groupBy("manager_id").having("sum(age) < {0}", 500);

        List> userList = userMapper.selectMaps(queryWrapper);
        for (Map map : userList) {
            System.out.println(map);
        }
    }

    /**
     * selectObjs()，只拿出数据的第一列的数据，其他列都被舍弃（sql中是会查询其他字段的，但是selectObjs()方法只选择第一列的数据）
     * 场景：只返回第一列的时候可以用它
     */
    @Test
    public void selectByWrapperObjs() {
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper
                .select("id", "name")
                //模糊查询，注意这里的字段都是数据库字段，而不是实体的变量名
                .like("name", "雨")
                //小于
                .lt("age", 40);
        List userList = userMapper.selectObjs(queryWrapper);
        for (Object o : userList) {
            System.out.println(o);
        }
    }

    /**
     * 统计查询
     */
    @Test
    public void selectByWrapperCount() {
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper
                //会帮我们在sql中添加 COUNT( 1 )，所以我们就不能使用select()方法来指定要查询的列了，否则会作为count的参数来使用
                //.select("id", "name")
                //除非你想count其他字段，就可以使用
                .select("id")
                //模糊查询，注意这里的字段都是数据库字段，而不是实体的变量名
                .like("name", "雨")
                //小于
                .lt("age", 40);
        Integer count = userMapper.selectCount(queryWrapper);
        System.out.println("count：" + count);
    }

    /**
     * 只查询出1条数据（必须查询结果只有1条，多条会报错）
     */
    @Test
    public void selectByWrapperOne() {
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper
                .select("id", "name")
                //模糊查询，注意这里的字段都是数据库字段，而不是实体的变量名
                .eq("name", "刘雨红");
        User user = userMapper.selectOne(queryWrapper);
        System.out.println(user);
    }

    /**
     * Lambda条件构造器
     * 好处：仿误写，如果是普通方式，传入数据库字段名，如果写错了就会报错，Lambda表达式使用方法引用来获取字段信息
     */
    @Test
    public void selectByWrapperLambda() {
        //Lambda条件构造器的3种创建方式
//        LambdaQueryWrapper queryWrapper = new QueryWrapper().lambda();
//        LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>();
        LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery();
        queryWrapper
                //where name like '%雨%'
                .like(User::getReadName, "雨")
                //and age < 40
                .lt(User::getAge, 40);
        List userList = userMapper.selectList(queryWrapper);
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 查询，姓名为王姓，并且（年龄小于40岁或者邮箱不为空）
     */
    @Test
    public void selectByWrapperLambda2() {
        LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery();
        queryWrapper
                //where name like '%王%'
                .likeRight(User::getReadName, "王")
                //and (age < 40 or email is not null)
                .and(lqw -> lqw.lt(User::getAge, 40).or().isNotNull(User::getEmail));
        List userList = userMapper.selectList(queryWrapper);
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 查询，姓名为王姓，并且年龄大于等于20
     */
    @Test
    public void selectByWrapperLambda3() {
        LambdaQueryChainWrapper chainWrapper = new LambdaQueryChainWrapper<>(userMapper);
        List userList = chainWrapper
                //姓名为王姓
                .like(User::getReadName, "雨")
                //年龄大于等于20
                .ge(User::getAge, 20)
                .list();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}
 
 
     
  
  • 分页查询
    •  
 
 
 
BaseMapper还提供了分页查询的相关方法。
 
 
     
  
  1. selectPage，传入分页参数Page对象，以及QueryWrapper条件构造器，返回IPage对象，IPage内有总页数、总记录数等分页参数
    2.  
  
  2. selectMapsPage，第二种分页方式，分页对象的泛型是Map，不是实体类对象，就是将实体类的字段和值封装到了Map中
    3.  
  
  3. selectPage，传入的Page分页对象，构造方法配置isSearchCount参数为false，表示分页但不查询总记录数，在不需要总记录数的场景下，可以减少一次查询，例如App端，加载更多是不需要总记录数做判断的
    4.  
 
 
 
/**
 * 分页查询，分页对象的泛型是实体类
 */
@Test
public void selectPage() {
    //直接创建一个条件构造器，获取使用Wrappers工具类
    QueryWrapper queryWrapper = new QueryWrapper<>();
    queryWrapper.ge("age", 26);
    Page page = new Page<>(1, 2);

    //分页
    IPage iPage = userMapper.selectPage(page, queryWrapper);

    System.out.println("总页数：" + iPage.getPages());
    System.out.println("总记录数：" + iPage.getTotal());
    List userList = iPage.getRecords();
    for (User user : userList) {
        System.out.println(user);
    }
}

/**
 * 第二种分页方式，分页对象的泛型是Map
 */
@Test
public void selectPage2() {
    //直接创建一个条件构造器，获取使用Wrappers工具类
    QueryWrapper queryWrapper = new QueryWrapper<>();
    queryWrapper.ge("age", 26);
    Page page = new Page<>(1, 2);

    //第二种分页，但返回的IPage泛型类型是Map类型，就是将实体类的字段和值封装到了Map中
    IPage> iPage = userMapper.selectMapsPage(page, queryWrapper);

    System.out.println("总页数：" + iPage.getPages());
    System.out.println("总记录数：" + iPage.getTotal());
    List> userList = iPage.getRecords();
    for (Map map : userList) {
        System.out.println(map);
    }
}

/**
 * 分页，不查询总记录数（默认会查，会查询总数和分页查询，会查询2次，例如不断上拉加载的场景是不需要查总记录数的，就可以不进行查询）
 */
@Test
public void selectPage3() {
    QueryWrapper queryWrapper = new QueryWrapper<>();
    queryWrapper.ge("age", 26);
    //isSearchCount传false，代表不进行查询总记录数，少一次查询
    Page page = new Page<>(1, 2, false);

    //分页
    IPage iPage = userMapper.selectPage(page, queryWrapper);

    System.out.println("总页数：" + iPage.getPages());
    List userList = iPage.getRecords();
    for (User user : userList) {
        System.out.println(user);
    }
}

 
 
自定义Mapper方法
 
 
提供自定义Mapper方法
 
 
给UserMapper增加2个自定义方法。
 
 
自定义方法有2种方式，注解和XML，这里主要用XML，但也提供了一条注解，因为他们不能同时存在，所以注释掉，有需要时，再参考即可
 
 
     
  
  1. selectAll，自定义查询参数，查询条件由传入的wrapper提供，参数要加上@Param注解，并且参数名是固定的，都是Constants.WRAPPER
    2.  
  
  2. selectUserPage，自定义查询参数，带分页功能，需要传个2参数，Page对象和Wrapper对象，同样参数要加上@Param注解，并且参数名是固定的，都是Constants.WRAPPER
    3.  
 
 
 
public interface UserMapper extends BaseMapper {
    /**
     * 自定义Sql查询，让Wrapper中配置的条件和自定义sql进行组合
     */
    //@Select("select * from mp_user ${ew.customSqlSegment}")
    List selectAll(@Param(Constants.WRAPPER) Wrapper wrapper);

    /**
     * 自定义Sql，进行分页查询
     */
    IPage selectUserPage(Page page, @Param(Constants.WRAPPER) Wrapper wrapper);
}

 
 
配置Mapper的XML文件
 
 
有自定义Mapper接口，要么用注解，要么就用XML，一般会使用XML。
 在resource目录下，建立多层文件夹，com/imooc/mybatisplus.mapper，文件夹内新建XML文件：UserMapper.xml
 
 
注意：Mapper接口和对应XML文件的名称要相同！以及命名空间是Mapper的全类名
 
 




    
    

    
    


 
 
测试自定义SQL的方法
 
 
条件在Wrapper实例中配置，查询的字段由自定义的SQL语句提供。
 
 
分别是查询selectAll()所有和selectMyPage()分页查询。
 
 
/**
 * 自定义sql
 */
@Test
public void selectMy() {
    LambdaQueryWrapper lambdaQuery = Wrappers.lambdaQuery();
    lambdaQuery
            //where name like '%王%'
            .likeRight(User::getReadName, "王")
            //and (age < 40 or email is not null)
            .and(lqw -> lqw.lt(User::getAge, 40).or().isNotNull(User::getEmail));
    List userList = userMapper.selectAll(lambdaQuery);
    for (User user : userList) {
        System.out.println(user);
    }
}

/**
 * 自定义查询分页
 */
@Test
public void selectMyPage() {
    QueryWrapper queryWrapper = new QueryWrapper<>();
    queryWrapper.ge("age", 26);
    Page page = new Page<>(1, 2);
    //自定义分页查询
    IPage iPage = userMapper.selectUserPage(page, queryWrapper);
    System.out.println("总页数：" + iPage.getPages());
    System.out.println("总记录数：" + iPage.getTotal());
    List userList = iPage.getRecords();
    for (User user : userList) {
        System.out.println(user);
    }
}

 
 
通用Service
 
 
上面我们使用的是通用Mapper，而一般我们会有Service组合多个Mapper来完成业务逻辑。
 
 
MyBatis-Plus也给我们提供了通用Service的方案。
 
 
建立Service接口和实现
 
 
建立service包，UserService接口，继承IService接口，泛型写实体类的类型
 
 
public interface UserService extends IService {
}

 
 
建立UserServiceImpl实现类，继承ServiceImpl，泛型传入Mapper接口和实体类类型
 
 
@Service
public class UserServiceImpl extends ServiceImpl implements UserService {
}

 
 
测试
 
 
     
  
  1. getOne，获取1个结果，如果有结果有多个，会报错。如果不想报错，默认取第一个，则将后面的throwEx属性设置为false
    2.  
  
  2. saveBatch，保存多个对象到数据库表，如果实体对象id字段有值，则为更新，为null，则代表新增
    3.  
  
  3. lambdaQuery，调用list，链式编程查询
    4.  
  
  4. lambdaUpdate，调用update，链式编程更新
    5.  
  
  5. lambdaUpdate，调用remove，链式编程删除
    6.  
 
 
 
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class ServiceTest {
    @Autowired
    private UserService userService;

    /**
     * 获取一个结果
     */
    @Test
    public void getOne() {
        //查询1个，如果有多个结果，会报错。
        //后面的throwEx属性代表如果查询出多个，是否抛出异常，默认为true，如果有多个就抛出异常
        //如果设置为false，则不抛出异常，打印警告，并且拿取第一个返回
        User result = userService.getOne(Wrappers.lambdaQuery()
                .gt(User::getAge, 25), false);
        System.out.println(result);
    }

    /**
     * 批量插入
     */
    @Test
    public void batch() {
        User user1 = new User();
        user1.setReadName("徐丽1");
        user1.setAge(28);

        User user2 = new User();
        user2.setReadName("徐丽2");
        user2.setAge(29);
        List userList = Arrays.asList(user1, user2);
        boolean isSuccess = userService.saveBatch(userList);
        System.out.println("是否批量插入成功：" + isSuccess);
    }

    /**
     * 批量操作，如果设置了id，则先查询，有则更新，无则做插入
     */
    @Test
    public void batch2() {
        User user1 = new User();
        user1.setReadName("徐丽3");
        user1.setAge(28);

        User user2 = new User();
        user2.setUserId(1289004540795330562L);
        user2.setReadName("徐力");
        user2.setAge(30);
        List userList = Arrays.asList(user1, user2);
        boolean isSuccess = userService.saveOrUpdateBatch(userList);
        System.out.println("是否批量插入成功：" + isSuccess);
    }

    /**
     * 链式编程，查询
     */
    @Test
    public void chain() {
        List userList = userService.lambdaQuery()
                .gt(User::getAge, 25)
                .like(User::getReadName, "雨")
                .list();
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 链式编程，更新
     */
    @Test
    public void chain2() {
        boolean isSuccess = userService.lambdaUpdate()
                .eq(User::getAge, 25)
                .set(User::getAge, 26)
                .update();
        System.out.println("是否更新成功：" + isSuccess);
    }

    /**
     * 链式编程，删除
     */
    @Test
    public void chain3() {
        boolean isSuccess = userService.lambdaUpdate()
                .eq(User::getAge, 24)
                .remove();
        System.out.println("是否删除成功：" + isSuccess);
    }
}

 
 
AR模式
 
 
AR模式，即ActiveRecord模式，用实体类操作增删查改，需要对实体类做修改。
 
 
     
  
  1. 实体类继承Model类，泛型传入实体类的类型
    2.  
  
  2. 生成序列化的UID
    3.  
 
 
 
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("mp_user")
public class User extends Model {
    private static final long serialVersionUID = 1L;

    //...省略字段，和之前的没区别
}

 
 
测试
 
 
     
  
  1. insert，插入数据
    2.  
  
  2. selectById，根据实体上的主键查询，也可以在方法参数上传入
    3.  
  
  3. updateById，根据实体主键更新实体上设置的数据
    4.  
  
  4. deleteById，根据实体主键删除，也可以在方法参数上传入
    5.  
  
  5. insertOrUpdate，新增或更新，根据实体主键是否有值判断，有值则为更新， 为null则为新增
    6.  
 
 
 
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class ARTest {
    /**
     * 插入数据
     */
    @Test
    public void insert() {
        User user = new User();
        user.setReadName("刘花");
        user.setAge(29);
        user.setEmail("[email protected]");
        user.setManagerId(1088248166370832385L);
        user.setCreateTime(LocalDateTime.now());
        boolean isSuccess = user.insert();
        System.out.println("是否插入成功：" + isSuccess);
    }

    /**
     * 按主键进行查询
     */
    @Test
    public void selectById() {
        User user = new User();
        User result = user.selectById(1288460195017072641L);
        System.out.println(result);
    }

    /**
     * 按实体类上的主键属性进行查询
     */
    @Test
    public void selectById2() {
        User user = new User();
        user.setUserId(1288839790966910978L);
        User result = user.selectById();
        System.out.println(result);
    }

    /**
     * 更新，按实体类上的主键属性
     */
    @Test
    public void updateById() {
        User user = new User();
        user.setUserId(1288839790966910978L);
        user.setReadName("刘草");
        boolean isSuccess = user.updateById();
        System.out.println("是否更新成功：" + isSuccess);
    }

    /**
     * 按主键删除
     */
    @Test
    public void deleteById() {
        User user = new User();
        boolean isSuccess = user.deleteById(1288839790966910978L);
        System.out.println("是否删除成功：" + isSuccess);
    }

    /**
     * 按实体类上的主键属性进行删除
     */
    @Test
    public void deleteById2() {
        User user = new User();
        user.setUserId(1288839790966910978L);
        boolean isSuccess = user.deleteById();
        System.out.println("是否删除成功：" + isSuccess);
    }

    /**
     * 先查询主键Id的记录，如果有则更新，无则新增
     */
    @Test
    public void insertOrUpdate() {
        User user = new User();
        //设置了主键Id，则会先查询，有记录则更新，无则删除
        //user.setUserId(1288842439342780417L);
        user.setReadName("张强");
        user.setAge(29);
        user.setEmail("[email protected]");
        user.setManagerId(1088248166370832385L);
        user.setCreateTime(LocalDateTime.now());
        boolean isSuccess = user.insertOrUpdate();
        System.out.println("是否插入成功：" + isSuccess);
    }
}

 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(MyBatis-Plus入门使用)

        

            

                
    
                    
  • python 读excel每行替换_Python脚本操作Excel实现批量替换功能
                        weixin_39646695
python读excel每行替换
                        
    Python脚本操作Excel实现批量替换功能大家好，给大家分享下如何使用Python脚本操作Excel实现批量替换。使用的工具Openpyxl，一个处理excel的python库，处理excel，其实针对的就是WorkBook，Sheet，Cell这三个最根本的元素~明确需求原始excel如下我们的目标是把下面excel工作表的sheet1表页A列的内容“替换我吧”批量替换为B列的“我用来替换的
    
                    
    • 
                    
  • 男士护肤品哪个牌子好？十大男士护肤品排行榜
                        高省APP珊珊

                        
    很多男生意识到护肤的必要性，开始着手护肤，但不知道该选哪个男士护肤品品牌使用好。目前市面上很多男士护肤品品牌，可谓琳琅满目，让人眼花缭乱。男士挑选护肤品时，根据自己皮肤需求去正规渠道挑选合适的知名护肤品比较放心靠谱。高省APP，是2021年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入
    
                    
    • 
                    
  • 三菱PLC全套学习资料及应用手册
                        good2know

                        
    本文还有配套的精品资源，点击获取简介：三菱PLC作为工业自动化领域的核心设备，其系列产品的学习和应用需要全面深入的知识。本次资料包为学习者提供从基础到进阶的全方位学习资源，包括各种型号PLC的操作手册、编程指南、软件操作教程以及实际案例分析，旨在帮助用户系统掌握PLC的编程语言、指令系统及在各类工业应用中的实施。1.三菱PLC基础知识入门1.1PLC的基本概念可编程逻辑控制器（PLC）是工业自动化
    
                    
    • 
                    
  • 9、汇编语言编程入门：从环境搭建到简单程序实现
                        神经网络酱
汇编语言MEPISGNU工具链
                        
    汇编语言编程入门：从环境搭建到简单程序实现1.数据存储介质问题解决在处理数据存储时，若要使用MEPIS系统，需确保有其可访问的存储介质。目前，MEPIS无法向采用NTFS格式（常用于Windows2000和XP工作站）的硬盘写入数据。不过，若硬盘采用FAT32格式，MEPIS就能进行写入操作。此外，MEPIS还能将文件写入软盘和大多数USB闪存驱动器。若工作站连接到局域网，还可通过FTP协议或挂载
    
                    
    • 
                    
  • 实时数据流计算引擎Flink和Spark剖析
                        程小舰
flinkspark数据库kafkahadoop
                        
    在过去几年，业界的主流流计算引擎大多采用SparkStreaming，随着近两年Flink的快速发展，Flink的使用也越来越广泛。与此同时，Spark针对SparkStreaming的不足，也继而推出了新的流计算组件。本文旨在深入分析不同的流计算引擎的内在机制和功能特点，为流处理场景的选型提供参考。（DLab数据实验室w.x.公众号出品）一.SparkStreamingSparkStreamin
    
                    
    • 
                    
  • 48. 旋转图像 - 力扣（LeetCode）
                        Fiee-77
#数组leetcode算法python数据结构数组
                        
    题目：给定一个n×n的二维矩阵matrix表示一个图像。请你将图像顺时针旋转90度。你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。示例1：输入：matrix=[[1,2,3],[4,5,6],[7,8,9]]输出：[[7,4,1],[8,5,2],[9,6,3]]示例2：输入：matrix=[[5,1,9,11],[2,4,8,10],[13,3,6,
    
                    
    • 
                    
  • Git 与 GitHub 的对比与使用指南
                        一念&
其它gitgithub
                        
    Git与GitHub的对比与使用指南在软件开发中，Git和GitHub是两个密切相关但本质不同的工具。下面我将逐步解释它们的定义、区别、核心概念以及如何协同使用，确保内容真实可靠，基于广泛的技术实践。1.什么是Git？Git是一个分布式版本控制系统，由LinusTorvalds于2005年创建。它的核心功能是跟踪代码文件的变化，帮助开发者管理项目历史记录、协作和回滚错误。Git是开源的，可以在本地
    
                    
    • 
                    
  • 在线人数统计业务设计（场景八股文）
                        

                        
    业务问题在当经的网站中，在线人数的实时统计已经是一个必不可少的模块了，并且该统计功能最好能够按不同的时间间隔做的统计，现在需要你设计一个在线人数统计的模块，你应该怎么进行设计的呢？背景一个网校下会有多个学员。目前平台大概有十个，平台对应的网校大概五十几个，平均一个网校会有5w个用户，预计总人数为200w，最该学员的在线人数在10w左右。设计思路最开始的时候，想到的就是使用mysql直接实现，但是明
    
                    
    • 
                    
  • 2018-09-27 aop相关
                        蒋超_58dc

                        
    1.静态织入，需要使用aspectj专用的compilermaven工程可以采用：https://www.mojohaus.org/aspectj-maven-plugin/2.动态织入，配合spring，创建代理来执行3.
    
                    
    • 
                    
  • Aop +反射 实现方法版本动态切换
                        

                        
    需求分析在做技术选型的时候一直存在着两个声音，mongo作为数据库比较mysql好，mysql做为该数据比mongo好。当然不同数据库都有有着自己的优势，我们在做技术选型的时候无非就是做到对数据库的扬长避短。mysql最大的优势就是支持事务，事务的五大特性保证的业务可靠性，随之而来的就是事务会产生的问题：脏读、幻读、不可重复度，当然我们也会使用不同的隔离级别来解决。（最典型的业务问题：银行存取钱）
    
                    
    • 
                    
  • 【ARM】FPU,VFP,ASE,NEON,SVE...是什么意思？
                        亿道电子Emdoor
ARMarm开发ARM
                        
    1、文档目标对执行浮点和SIMD操作的逻辑的各种名称的缩写词进行简要解释。2、问题场景Arm处理器内核中有用于执行浮点和SIMD操作的逻辑，有各种名称。它们通常是一系列的缩写形式，因此本文旨在对每一个缩写词进行简要解释。3、软硬件环境1、软件版本：不涉及2、电脑环境：不涉及4、相关缩写FPU(Floating-PointUnit)浮点单元浮点单元是处理器核心中的一个模块，用于使用浮点数执行算术运算
    
                    
    • 
                    
  • 基于redis的Zset实现作者的轻量级排名
                        周童學
Javaredis数据库缓存
                        
    基于redis的Zset实现轻量级作者排名系统在今天的技术架构中，Redis是一种广泛使用的内存数据存储系统，尤其在需要高效检索和排序的场景中表现优异。在本篇博客中，我们将深入探讨如何使用Redis的有序集合（ZSet）构建一个高效的笔记排行榜系统，并提供相关代码示例和详细的解析。1.功能背景与需求假设我们有一个笔记分享平台，用户可以发布各种笔记，系统需要根据用户发布的笔记数量来生成一个实时更新的
    
                    
    • 
                    
  • 【异常】使用 LiteFlow 框架时，提示错误ChainDuplicateException: [chain name duplicate] chainName=categoryChallenge
                        本本本添哥
002-进阶开发能力java
                        
    一、报错内容Causedby:com.yomahub.liteflow.exception.ChainDuplicateException:[chainnameduplicate]chainName=categoryChallengeatcom.yomahub.liteflow.parser.helper.ParserHelper.lambda$null$0(ParserHelper.java:1
    
                    
    • 
                    
  • Java并发核心：线程池使用技巧与最佳实践！ | 多线程篇(五)
                        bug菌¹
Java实战(进阶版)javaJava零基础入门Java并发线程池多线程篇
                        
    本文收录于「Java进阶实战」专栏，专业攻坚指数级提升，希望能够助你一臂之力，帮你早日登顶实现财富自由；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！环境说明：Windows10+IntelliJIDEA2021.3.2+Jdk1.8本文目录前言摘要正文何为线程池？为什么需要线程池？线程池的好处线程池使用场景如何创建线程池？线程池的常见配置源码解析案例分享案例代码演示案例运行
    
                    
    • 
                    
  • STM32入门之TIM基本定时器
                        嵌入式白话
STM32入门学习stm32嵌入式硬件单片机
                        
    一、定时器简介定时器是嵌入式系统中的关键外设之一，它可以用于生成精确的延时、周期性中断、PWM波形生成等功能。在STM32F1系列单片机中，定时器不仅能为系统提供精确的时钟，还支持外部事件的捕获以及信号输出。对于定时器的功能，我们可以通过一个生活中非常常见的例子来形象地描述：微波炉的定时器。想象你正在使用微波炉加热食物。在微波炉里，定时器的作用就是帮助你控制食物加热的时间。当你设置了加热时间后，定
    
                    
    • 
                    
  • 常规笔记本和加固笔记本的区别
                        luchengtech
电脑三防笔记本加固计算机加固笔记本
                        
    在现代科技产品中，笔记本电脑因其便携性和功能性被广泛应用。根据使用场景和需求的不同，笔记本可分为常规笔记本和加固笔记本，二者在多个方面存在显著区别。适用场景是区分二者的重要标志。常规笔记本主要面向普通消费者和办公人群，适用于家庭娱乐、日常办公、学生学习等相对稳定的室内环境。比如，人们在家用它追剧、处理文档，学生在教室用它完成作业。而加固笔记本则专为特殊行业设计，像军事、野外勘探、工业制造、交通运输
    
                    
    • 
                    
  • 云集怎么赚钱？云集APP分享购物赚钱攻略
                        古楼

                        
    云集app怎么赚钱?云集app作为是一个全面的电商导购平台,提供诸如淘宝、京东、拼多多等各大平台的优惠券,其他同类型的导购平台相比,更加的全面,线上线下全面出击。如果你想通过云集赚钱,那你可以把这款APP推荐给淘宝(10亿用户)、拼多多(3亿用户)、京东(1亿用户)使用,那你能赚到他们购物返佣,也可以自己购物领优惠券能省不少钱,以后还有更多的商家与粉象合作,这么免费的App人人都需要,很好推广。至
    
                    
    • 
                    
  • 为了在未来的人工智能世界中取得成功，学生们必须学习人类写作的优点
                        睿邸管家

                        
    澳大利亚各地的学生在新学年开始使用铅笔、钢笔和键盘学习写字。在工作场所，机器也在学习写作，如此有效，几年之内，它们可能会写得比人类更好。有时它们已经做到了，就像Grammarly这样的应用程序所展示的那样。当然，人类现在的日常写作可能很快就会由具有人工智能(AI)的机器来完成。手机和电子邮件软件常用的预测文本是无数人每天都在使用的一种人工智能写作形式。据AI行业研究机构称，到2022年，人工智能及
    
                    
    • 
                    
  • 淘宝内部优惠劵领取教程，淘宝内部优惠劵软件使用方法！
                        测评君高省

                        
    淘宝优惠券一般分为2种：第1种：是你在淘宝上买东西经常能看到的那种店铺优惠券，商家主动将一些有门槛的优惠券摆在旁边，这种券一般需要你满足消费金额或者去邀请好友才能减个几块钱。第2种：就是淘宝内部优惠券，商家为了打造爆款时会低价促销从而发放一些低价优惠券，只要下单就能立减，而且优惠的金额都非常高。但是为了控制成本并设置一定的销售目标，一旦达成预订销售额，就会停止发送优惠券。优惠劵导购平台哪个好？今天
    
                    
    • 
                    
  • 严重的DDoS 攻击澳大利亚主要宽带提供商
                        Fancy1816575412

                        
    本周早些时候，澳大利亚最大的固定无线宽带运营商CirrusCommunications遭受了一次重大的DDoS攻击，导致其一半以上的网络瘫痪。该公司在其网站上声称：“强大的架构、数百个传输站点以及光纤和微波回程的使用使其能够以非常高的正常运行时间提供高速”。CirrusCommunications表示，它覆盖了澳大利亚十大人口中心以及几个主要的区域中心，主要为企业和政府客户提供服务。然而，据The
    
                    
    • 
                    
  • Selenium 特殊控件操作与 ActionChains 实践详解
                        小馋喵知识杂货铺
selenium测试工具
                        
    1.下拉框单选操作(a)使用SeleniumSelect类（标准HTML标签）Selenium提供了内置的Select类用于操作标准下拉框，这种方式简单且直观。fromselenium.webdriver.support.uiimportSelect#定位下拉框dropdown=Select(driver.find_element("id","dropdown_id"))#通过以下三种方式选择单个
    
                    
    • 
                    
  • Pktgen-DPDK：开源网络测试工具的深度解析与应用
                        艾古力斯

                        
    本文还有配套的精品资源，点击获取简介：Pktgen-DPDK是基于DPDK的高性能流量生成工具，适用于网络性能测试、硬件验证及协议栈开发。它支持多种网络协议，能够模拟高吞吐量的数据包发送。本项目通过利用DPDK的高速数据包处理能力，允许用户自定义数据包内容，并实现高效的数据包管理与传输。文章将指导如何安装DPDK、编译Pktgen、配置工具以及使用方法，最终帮助开发者和网络管理员深入理解并优化网络
    
                    
    • 
                    
  • 微信公众号回调java_处理微信公众号消息回调
                        weixin_39607620
微信公众号回调java
                        
    1、背景在上一节中，咱们知道如何接入微信公众号，可是以后公众号会与咱们进行交互，那么微信公众号如何通知到咱们本身的服务器呢？咱们知道咱们接入的时候提供的url是GET/mp/entry，那么公众号以后产生的事件将会以POST/mp/entry发送到咱们本身的服务器上。html2、代码实现，此处仍是使用weixin-java-mp这个框架实现一、引入weixin-java-mpcom.github.
    
                    
    • 
                    
  • C++编程基础与面向对象概念解析
                        侯昂
面向对象编程C++语法函数类与对象继承与多态性
                        
    C++编程基础与面向对象概念解析背景简介C++是一种广泛使用的面向对象编程语言，它允许开发者创建高效、灵活且功能强大的程序。本文基于《C++Primer》一书的章节内容，深入解析C++的核心概念和面向对象编程原则，旨在帮助读者构建扎实的C++编程基础。面向对象编程的原则软件危机与进化介绍了软件危机的产生和软件进化的必要性，强调了面向对象编程（OOP）在应对这些问题中的优势。面向对象编程范式讨论了面
    
                    
    • 
                    
  • 手把手教你用C语言实现顺序表
                        

                        
    hello，大家好，本篇文章旨在为大家讲解如何使用C语言实现顺序表，还有就是小编自己复习一下相关知识，OK，那我们现在开始。在通讯录中，有增删查改等功能，那么顺序表我们也会对以上功能进行实现。一、创建并初始化顺序表1.创建typedefintSLDataType;#defineINIT_CAPACITY4//动态顺序表--按需申请typedefstructSeqList{SLDataType*a;
    
                    
    • 
                    
  • selenium特殊场景处理
                        Monica_ll
Seleniumseleniumchromepython
                        
    文章目录前言一、多窗口处理二、浏览器弹窗处理包含alert、confirm、prompt三、鼠标和键盘事件处理前言在使用selenium操作浏览器的过程中可能需要借助键盘和鼠标功能完成一些操作，或者操作弹窗处理，本文主要是整理自己工作过程中使用过的一些方法一、多窗口处理在实际测试过程中经常会有通过点击或者连接打开新的窗口，这种情况下就需要切换webDriver到对应浏览器对象才能操作新窗口的元素。
    
                    
    • 
                    
  • 环境搭建 | Python + Anaconda / Miniconda + PyCharm 的安装、配置与使用
                        

                        
    本文将分别介绍Python、Anaconda/Miniconda、PyCharm的安装、配置与使用，详细介绍Python环境搭建的全过程，涵盖Python、Pip、PythonLauncher、Anaconda、Miniconda、Pycharm等内容，以官方文档为参照，使用经验为补充，内容全面而详实。由于图片太多，就先贴一个无图简化版吧，详情请查看Python+Anaconda/Minicond
    
                    
    • 
                    
  • Qwen3 大模型实战：使用 vLLM 部署与函数调用（Function Call）全攻略
                        曦紫沐
大模型大模型部署Qwen3vLLM函数调用
                        
    文章摘要本文将带你从零开始，深入掌握如何使用Qwen3-8B大语言模型，结合vLLM进行高性能部署，并通过函数调用（FunctionCall）实现模型与外部工具的智能联动。我们将详细讲解部署命令、调用方式、代码示例及实际应用场景，帮助你快速构建基于Qwen3的智能应用。一、Qwen3简介与部署环境准备Qwen3是通义千问系列的最新一代大语言模型，具备强大的自然语言理解和生成能力，尤其在函数调用、工
    
                    
    • 
                    
  • 链商拉不到人能赚钱么，谈谈我的看法
                        糖葫芦不甜

                        
    链商作为一种新兴的商业形态，往往依赖于用户网络的扩展和交易量的增加来实现价值增长，但这并不意味着没有直接拉新就无法盈利。以下是我对这一问题的几点看法：招合作伙伴↓微信在文章底部。首先，链商能否赚钱，关键在于其是否能提供独特且有价值的产品或服务。如果链商平台能够构建出高效、透明、安全的价值交换体系，解决行业痛点，提升用户体验，那么即使没有大规模的拉新活动，也能通过现有用户的口碑传播和持续使用来产生稳
    
                    
    • 
                    
  • vllm本地台式机运行(3070显存8G)
                        名明鸣冥
pythonQwenvllm大模型部署
                        
    ollama和vllm的对比这块对比网上都很多资料了，这边使用上简单感觉就是ollama很方便部署,占用资料更少,但后续性能会差点,各选项也不一样.ollama安装和使用和docker很像,就不赘述了,这里是看vllm的安装硬件情况介绍30708G显存+-------------------------------------------------------------------------
    
                    
    • 
                                
  • js动画html标签（持续更新中）
                                    843977358
htmljs动画mediaopacity
                                    
    1.jQuery 效果 - animate() 方法    改变 "div" 元素的高度：    $(".btn1").click(function(){      $("#box").animate({height:"300px
    
                                
    • 
                                
  • springMVC学习笔记
                                    caoyong
springMVC
                                    
    1、搭建开发环境 
   a>、添加jar文件，在ioc所需jar包的基础上添加spring-web.jar,spring-webmvc.jar 
   b>、在web.xml中配置前端控制器 
      <servlet> 
    &nbs
    
                                
    • 
                                
  • POI中设置Excel单元格格式
                                    107x
poistyle列宽合并单元格自动换行
                                    
    引用：http://apps.hi.baidu.com/share/detail/17249059 
POI中可能会用到一些需要设置EXCEL单元格格式的操作小结： 
先获取工作薄对象: 
HSSFWorkbook wb = new HSSFWorkbook(); 
HSSFSheet sheet = wb.createSheet(); 
HSSFCellStyle setBorder = wb.
    
                                
    • 
                                
  • jquery 获取A href 触发js方法的this参数 无效的情况
                                    一炮送你回车库
jquery
                                    
    html如下：  
<td class=\"bord-r-n bord-l-n c-333\"> 
<a class=\"table-icon edit\" onclick=\"editTrValues(this);\">修改</a> 
</td>" 
  
j
    
                                
    • 
                                
  • md5
                                    3213213333332132
MD5
                                    
    
import java.security.MessageDigest;  
import java.security.NoSuchAlgorithmException;  
  
public class MDFive {  
    public static void main(String[] args) {  
        String md5Str = "cq
    
                                
    • 
                                
  • 完全卸载干净Oracle11g
                                    sophia天雪
orale数据库卸载干净清理注册表
                                    
    完全卸载干净Oracle11g 
A、存在OUI卸载工具的情况下： 
    第一步：停用所有Oracle相关的已启动的服务； 
    第二步：找到OUI卸载工具：在“开始”菜单中找到“oracle_OraDb11g_home”文件夹中 
        &
    
                                
    • 
                                
  • apache 的access.log 日志文件太大如何解决
                                    darkranger
apache
                                    
    CustomLog logs/access.log common  此写法导致日志数据一致自增变大。 
直接注释上面的语法 
#CustomLog logs/access.log common 
增加： 
CustomLog "|bin/rotatelogs.exe -l logs/access-%Y-%m-d.log 
    
                                
    • 
                                
  • Hadoop单机模式环境搭建关键步骤
                                    aijuans
分布式
                                    
            Hadoop环境需要sshd服务一直开启，故，在服务器上需要按照ssh服务，以Ubuntu Linux为例，按照ssh服务如下： 
sudo apt-get install ssh 
sudo apt-get install rsync 
编辑HADOOP_HOME/conf/hadoop-env.sh文件，将JAVA_HOME设置为Java
    
                                
    • 
                                
  • PL/SQL DEVELOPER 使用的一些技巧
                                    atongyeye
javasql
                                    
    1 记住密码  
 
这是个有争议的功能，因为记住密码会给带来数据安全的问题。 但假如是开发用的库，密码甚至可以和用户名相同，每次输入密码实在没什么意义，可以考虑让PLSQL Developer记住密码。 位置：Tools菜单－－Preferences－－Oracle－－Logon HIstory－－Store with password 
 
 
2 特殊Copy  
 
在SQL Window
    
                                
    • 
                                
  • PHP：在对象上动态添加一个新的方法
                                    bardo
方法动态添加闭包
                                    
    有关在一个对象上动态添加方法，如果你来自Ruby语言或您熟悉这门语言，你已经知道它是什么...... Ruby提供给你一种方式来获得一个instancied对象，并给这个对象添加一个额外的方法。 
  
好！不说Ruby了，让我们来谈谈PHP 
  
PHP未提供一个“标准的方式”做这样的事情，这也是没有核心的一部分... 
  
但无论如何，它并没有说我们不能做这样
    
                                
    • 
                                
  • ThreadLocal与线程安全
                                    bijian1013
javajava多线程threadLocal
                                    
    首先来看一下线程安全问题产生的两个前提条件：  
1.数据共享，多个线程访问同样的数据。  
2.共享数据是可变的，多个线程对访问的共享数据作出了修改。  
  
实例： 
        定义一个共享数据： 
public static int a = 0; 
        
    
                                
    • 
                                
  • Tomcat 架包冲突解决
                                    征客丶
tomcatWeb
                                    
    环境： 
Tomcat 7.0.6 
win7 x64 
 
错误表象：【我的冲突的架包是：catalina.jar 与 tomcat-catalina-7.0.61.jar 冲突，不知道其他架包冲突时是不是也报这个错误】 
严重: End event threw exception 
java.lang.NoSuchMethodException: org.apache.catalina.dep
    
                                
    • 
                                
  • 【Scala三】分析Spark源代码总结的Scala语法一
                                    bit1129
scala
                                    
    Scala语法 1. classOf运算符 
Scala中的classOf[T]是一个class对象，等价于Java的T.class,比如classOf[TextInputFormat]等价于TextInputFormat.class 
   2. 方法默认值 
defaultMinPartitions就是一个默认值，类似C++的方法默认值 
  
  
 
    
                                
    • 
                                
  • java 线程池管理机制
                                    BlueSkator
java线程池管理机制
                                    
    编辑 
Add 
Tools 
  jdk线程池 
  
一、引言 
第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。 
  
    
                                
    • 
                                
  • 关于hql中使用本地sql函数的问题（问-答）
                                    BreakingBad
HQL存储函数
                                    
    转自于：http://www.iteye.com/problems/23775 
问： 
我在开发过程中，使用hql进行查询（mysql5）使用到了mysql自带的函数find_in_set()这个函数作为匹配字符串的来讲效率非常好，但是我直接把它写在hql语句里面（from ForumMemberInfo fm,ForumArea fa where find_in_set(fm.userId,f
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-迭代器模式-Iterator
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 



import java.util.Arrays;
import java.util.List;

/**
 * Iterator模式提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象内部表示
 * 
 * 个人觉得，为了不暴露该
    
                                
    • 
                                
  • 常用SQL
                                    chenjunt3
oraclesqlC++cC#
                                    
      
  
--NC建库
CREATE TABLESPACE NNC_DATA01 DATAFILE 'E:\oracle\product\10.2.0\oradata\orcl\nnc_data01.dbf' SIZE 500M AUTOEXTEND ON NEXT 50M EXTENT MANAGEMENT LOCAL UNIFORM SIZE 256K ;
CREATE TABLESPA
    
                                
    • 
                                
  • 数学是科学技术的语言
                                    comsci
工作活动领域模型
                                    
      从小学到大学都在学习数学，从小学开始了解数字的概念和背诵九九表到大学学习复变函数和离散数学，看起来好像掌握了这些数学知识，但是在工作中却很少真正用到这些知识，为什么？ 
 
   最近在研究一种开源软件-CARROT2的源代码的时候，又一次感觉到数学在计算机技术中的不可动摇的基础作用，CARROT2是一种用于自动语言分类（聚类）的工具性软件，用JAVA语言编写，它
    
                                
    • 
                                
  • Linux系统手动安装rzsz 软件包
                                    daizj
linuxszrz
                                    
    1、下载软件 rzsz-3.34.tar.gz。登录linux，用命令 
 
wget http://freeware.sgi.com/source/rzsz/rzsz-3.48.tar.gz下载。 
 
2、解压 tar zxvf  rzsz-3.34.tar.gz 
 
3、安装  cd rzsz-3.34 ; make posix 。注意：这个软件安装与常规的GNU软件不
    
                                
    • 
                                
  • 读源码之:ArrayBlockingQueue
                                    dieslrae
java
                                    
        ArrayBlockingQueue是concurrent包提供的一个线程安全的队列,由一个数组来保存队列元素.通过 
takeIndex和 
putIndex来分别记录出队列和入队列的下标,以保证在出队列时 
不进行元素移动. 
 
 

//在出队列或者入队列的时候对takeIndex或者putIndex进行累加,如果已经到了数组末尾就又从0开始,保证数
    
                                
    • 
                                
  • C语言学习九枚举的定义和应用
                                    dcj3sjt126com
c
                                    
    枚举的定义 
# include <stdio.h>

enum WeekDay
{
	MonDay, TuesDay, WednesDay, ThursDay, FriDay, SaturDay, SunDay	
};

int main(void)
{	
	//int day;	//day定义成int类型不合适
	enum WeekDay day = Wedne
    
                                
    • 
                                
  • Vagrant 三种网络配置详解
                                    dcj3sjt126com
vagrant
                                    
     
 Forwarded port 
 Private network 
 Public network 
 
Vagrant 中一共有三种网络配置，下面我们将会详解三种网络配置各自优缺点。 
端口映射(Forwarded port)，顾名思义是指把宿主计算机的端口映射到虚拟机的某一个端口上，访问宿主计算机端口时，请求实际是被转发到虚拟机上指定端口的。Vagrantfile中设定语法为：   
c
    
                                
    • 
                                
  • 16.性能优化-完结
                                    frank1234
性能优化
                                    
    性能调优是一个宏大的工程，需要从宏观架构(比如拆分，冗余，读写分离，集群，缓存等)， 软件设计（比如多线程并行化，选择合适的数据结构）， 数据库设计层面（合理的表设计，汇总表，索引，分区，拆分，冗余等） 以及微观（软件的配置，SQL语句的编写，操作系统配置等）根据软件的应用场景做综合的考虑和权衡，并经验实际测试验证才能达到最优。 
 
性能水很深， 笔者经验尚浅 ，赶脚也就了解了点皮毛而已，我觉得
    
                                
    • 
                                
  • Word Search
                                    hcx2013
search
                                    
    Given a 2D board and a word, find if the word exists in the grid. 
The word can be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or ve
    
                                
    • 
                                
  • Spring4新特性——Web开发的增强
                                    jinnianshilongnian
springspring mvcspring4
                                    
    Spring4新特性——泛型限定式依赖注入 
Spring4新特性——核心容器的其他改进 
Spring4新特性——Web开发的增强 
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  
Spring4新特性——Groovy Bean定义DSL 
Spring4新特性——更好的Java泛型操作API  
Spring4新
    
                                
    • 
                                
  • CentOS安装配置tengine并设置开机启动
                                    liuxingguome
centos
                                    
    yum install gcc-c++  
yum install pcre pcre-devel  
yum install zlib zlib-devel  
yum install openssl openssl-devel 
 
Ubuntu上可以这样安装 
sudo aptitude install libdmalloc-dev libcurl4-opens
    
                                
    • 
                                
  • 第14章 工具函数（上）
                                    onestopweb
函数
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • Xelsius 2008 and SAP BW at a glance
                                    blueoxygen
BOXelsius
                                    
    Xelsius提供了丰富多样的数据连接方式，其中为SAP BW专属提供的是BICS。那么Xelsius的各种连接的优缺点比较以及Xelsius是如何直接连接到BEx Query的呢？ 以下Wiki文章应该提供了全面的概览。 
  
http://wiki.sdn.sap.com/wiki/display/BOBJ/Xcelsius+2008+and+SAP+NetWeaver+BW+Co
    
                                
    • 
                                
  • oracle表空间相关
                                    tongsh6
oracle
                                    
    在oracle数据库中，一个用户对应一个表空间，当表空间不足时，可以采用增加表空间的数据文件容量，也可以增加数据文件，方法有如下几种： 
 
1.给表空间增加数据文件 
   ALTER TABLESPACE "表空间的名字" ADD DATAFILE 
   '表空间的数据文件路径' SIZE 50M; 
  &nb
    
                                
    • 
                                
  • .Net framework4.0安装失败
                                    yangjuanjava
.netwindows
                                    
    上午的.net framework 4.0，各种失败，查了好多答案，各种不靠谱，最后终于找到答案了 
和Windows Update有关系，给目录名重命名一下再次安装，即安装成功了！ 
下载地址：http://www.microsoft.com/en-us/download/details.aspx?id=17113 
方法： 
1.运行cmd，输入net stop WuAuServ 
2.点击开
    
                                
    •