• 1. 分页+高级查询+关联查询
  • 1.1 步骤分析
  • 1.2 步骤实现
• 2. 日志集成
  • 2.1 步骤分析
  • 2.2 步骤实现
• 3. 机构管理
• 4. 机构入驻
  • 4.1 步骤分析
  • 4.2 步骤实现
• 5. logo图片处理见SAAS-HRM-day4

1. 分页+高级查询+关联查询

1.1 步骤分析

1. 准备分页插件配置
2. controller为自己的方法
3. service的impl
4. mapper
5. mapper.xml

1.2 步骤实现

1. 准备分页插件配置

package cn.wangningbo.hrm.config;

import com.baomidou.mybatisplus.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

//Spring boot方式:配置分页插件
@EnableTransactionManagement
@Configuration
@MapperScan(" cn.itsource.hrm.mapper")
public class MybatisPlusConfig {

    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

2. controller为自己的方法

    /**
     * 分页查询数据
     *
     * @param query 查询对象
     * @return PageList 分页对象
     */
    @RequestMapping(value = "/json", method = RequestMethod.POST)
    public PageList<CourseType> json(@RequestBody CourseTypeQuery query) {
        return courseTypeService.selectPageList(query);
    }

3. service的impl

    public PageList<CourseType> selectPageList(CourseTypeQuery query) {
        Page page = new Page(query.getPage(), query.getRows());
        List<CourseType> list = courseTypeMapper.loadListPage(page, query);
        return new PageList<>(page.getTotal(), list);
    }

4. mapper

public interface CourseTypeMapper extends BaseMapper<CourseType> {

    List<CourseType> loadListPage(Pagination page, @Param("query") CourseTypeQuery query);
}

5. mapper.xml

    <select id="loadListPage" parameterType="CourseTypeQuery" resultMap="CourseTypeMap">
        SELECT
            ct.*, pct.id ppid,
            pct. NAME pname
        FROM
            t_course_type ct
        LEFT JOIN t_course_type pct ON ct.pid = pct.id
        <include refid="whereSql"></include>
    </select>
    <sql id="whereSql">
      <where>
          <if test="query.keyword!=null and query.keyword!=''">
              AND (ct.name like concat('%',#{query.keyword},'%')) or (ct.description like concat('%',#{query.keyword},'%'))
          </if>
      </where>
    </sql>
    <resultMap id="CourseTypeMap" type="CourseType">
        <id column="id" property="id" />
        <result column="createTime" property="createTime" />
        <result column="updateTime" property="updateTime" />
        <result column="name" property="name" />
        <result column="pid" property="pid" />
        <result column="logo" property="logo" />
        <result column="description" property="description" />
        <result column="sortIndex" property="sortIndex" />
        <result column="path" property="path" />
        <result column="totalCount" property="totalCount" />
        <association property="parent" javaType="CourseType">
            <id column="ppid" property="id"></id>
            <result column="pname" property="name"></result>
        </association>
    </resultMap>

2. 日志集成

2.1 步骤分析

因为springboot默认使用日志框架是logback，我也要使用这个，所以我只需要自定义一些配置就行了！写个配置文件，取固定的名字即可！名字有两种选择方式logback-spring.xml和logback.xml！logback-spring.xml这个名字更牛逼一点！

在每个项目的服务那里都配置一下日志

1. 在每个服务下面的resources下都弄一个logback的配置文件名字为logback-spring.xml

2.2 步骤实现

logback-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--
scan：当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。
scanPeriod：设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒当scan为true时，此属性生效。默认的时间间隔为1分钟。
debug：当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。
-->
<configuration scan="false" scanPeriod="60 seconds" debug="false">
    <!-- 定义日志的根目录 -->
    <property name="LOG_HOME" value="/hrm/" />
    <!-- 定义日志文件名称 -->
    <property name="appName" value="hrm-sysmanage"></property>
    <!-- ch.qos.logback.core.ConsoleAppender 表示控制台输出 -->
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <!--
        日志输出格式：
            %d表示日期时间，
            %thread表示线程名，
            %-5level：级别从左显示5个字符宽度
            %logger{50} 表示logger名字最长50个字符，否则按照句点分割。 
            %msg：日志消息，
            %n是换行符
        -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </layout>
    </appender>

    <!-- 滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件 -->  
    <appender name="appLogAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 指定日志文件的名称
           /hrm/hrm-course/hrm-course.log
        -->
        <file>${LOG_HOME}/${appName}/${appName}.log</file>
        <!--
        当发生滚动时，决定 RollingFileAppender 的行为，涉及文件移动和重命名
        TimeBasedRollingPolicy： 最常用的滚动策略，它根据时间来制定滚动策略，既负责滚动也负责出发滚动。
        -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--
            滚动时产生的文件的存放位置及文件名称 %d{yyyy-MM-dd}：按天进行日志滚动 
            %i：当文件大小超过maxFileSize时，按照i进行文件滚动
            -->
            <fileNamePattern>${LOG_HOME}/${appName}/${appName}-%d{yyyy-MM-dd}-%i.log</fileNamePattern>
            <!-- 
            可选节点，控制保留的归档文件的最大数量，超出数量就删除旧文件。假设设置每天滚动，
            且maxHistory是365，则只保存最近365天的文件，删除之前的旧文件。注意，删除旧文件是，
            那些为了归档而创建的目录也会被删除。
            -->
            <MaxHistory>365</MaxHistory>
            <!-- 
            当日志文件超过maxFileSize指定的大小是，根据上面提到的%i进行日志文件滚动 注意此处配置SizeBasedTriggeringPolicy是无法实现按文件大小进行滚动的，必须配置timeBasedFileNamingAndTriggeringPolicy
            -->
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
        <!-- 日志输出格式： -->     
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [ %thread ] - [ %-5level ] [ %logger{50} : %line ] - %msg%n</pattern>
        </layout>
    </appender>

    <!-- 
        logger主要用于存放日志对象，也可以定义日志类型、级别
        name：表示匹配的logger类型前缀，也就是包的前半部分
        level：要记录的日志级别，包括 TRACE < DEBUG < INFO < WARN < ERROR
        additivity：作用在于children-logger是否使用 rootLogger配置的appender进行输出，
        false：表示只用当前logger的appender-ref，true：
        表示当前logger的appender-ref和rootLogger的appender-ref都有效
    -->
    <!-- hibernate logger -->
    <logger name="cn.wangningbo" level="debug" />
    <!-- Spring framework logger -->
    <logger name="org.springframework" level="debug" additivity="false"></logger>



    <!-- 
    root与logger是父子关系，没有特别定义则默认为root，任何一个类只会和一个logger对应，
    要么是定义的logger，要么是root，判断的关键在于找到这个logger，然后判断这个logger的appender和level。 
    -->
    <root level="info">
        <appender-ref ref="stdout" />
        <appender-ref ref="appLogAppender" />
    </root>
</configuration> 

3. 机构管理

4. 机构入驻

如果操作的domain涉及到了关联查询，就要在那个domain里面加入新的关联对象，并且在关联对象上面打上注解@TableField(exist=false)

4.1 步骤分析

1. domain处理
2. 前台根据指定格式传递过来参数
3. 由于中间表没有自己的mapper增删改查方法，所以我在TenantMapper里面自己写方法实现
4. 后台覆写service的实现使用自己的方式进行保存、修改、删除

4.2 步骤实现

1. domain处理

    //接收或者做关联查询，数据库中没有的字段
    @TableField(exist = false)
    private Employee adminUser;
    @TableField(exist = false)
    List<Meal> meals = new ArrayList<>();

    // 处理中间表
    public List<Map<String,Long>> getMealsMap(){
        List<Map<String,Long>> maps = new ArrayList<>();
        if (meals.size()>0){
            for (Meal meal : meals) {
                Map<String,Long> map = new HashMap<>();
                map.put("tenantId",this.getId());
                map.put("mealId",meal.getId());
                maps.add(map);
            }
        }
        return maps;
    }

2. 前台根据指定格式传递过来参数
3. 由于中间表没有自己的mapper增删改查方法，所以我在TenantMapper里面自己写方法实现

public interface TenantMapper extends BaseMapper<Tenant> {

    //保存中间表信息
    void saveTenantMeals(List<Map<String, Long>> mealsMap);

    //删除中间表信息
    void removeTenantMeal(Serializable id)
}

    <!--// 添加中间表void saveTenantMeals(List<Map<String, Long>> mealsMap);-->
    <insert id="saveTenantMeals" parameterType="arrayList">
        insert into t_tenant_meal(tenant_id,meal_id) VALUES
        <foreach collection="list" separator="," item="item">
            (#{item.tenantId},#{item.mealId})
        </foreach>
    </insert>

    <!--// 删除中间表 void removeTenantMeal(Serializable id);-->
    <delete id="removeTenantMeal" parameterType="long">
        DELETE  from t_tenant_meal where tenant_id =#{id}
    </delete>

4. 后台覆写service的实现使用自己的方式进行保存、修改、删除

@Service
public class TenantServiceImpl extends ServiceImpl<TenantMapper, Tenant> implements ITenantService {
    //注入租户
    @Autowired
    private TenantMapper tenantMapper;
    //注入用户
    @Autowired
    private EmployeeMapper employeeMapper;

    @Override
    public boolean insert(Tenant tenant) {
        //添加机构
        tenant.setRegisterTime(new Date());
        tenant.setState(false);
        tenantMapper.insert(tenant);
        System.out.println("添加后返回的id："+tenant.getId());
        //添加管理员
        Employee adminUser = tenant.getAdminUser();
        adminUser.setInputTime(new Date());
        adminUser.setTenantId(tenant.getId());
        adminUser.setType(true);//是否是租户管理员
        adminUser.setState(0);
        employeeMapper.insert(adminUser);
        //添加套餐中间表
        tenantMapper.saveTenantMeals(tenant.getMealsMap());
        return true;
    }

    @Override
    public boolean deleteById(Serializable id) {
        //删除机构
        tenantMapper.deleteById(id);
        //删除管理员 //根据条件删除
        Wrapper<Employee> wapper = new EntityWrapper<>();
        wapper.eq("tenant_id",id);
        employeeMapper.delete(wapper);
        //删除中间表
        tenantMapper.removeTenantMeal(id);
        return true;
    }

    @Override
    public boolean updateById(Tenant tenant) {
        //修改机构
        tenantMapper.updateById(tenant);
        //修改管理员
        employeeMapper.updateById(tenant.getAdminUser());
        //修改中间表 //这里采用先删除后添加的方式
        tenantMapper.removeTenantMeal(tenant.getId());
        tenantMapper.saveTenantMeals(tenant.getMealsMap());
        return true;
    }
}

5. logo图片处理见SAAS-HRM-day4