加油！！！

今天完成的事：

完成接口文档，创建工程，写好假数据，使用postman进行测试所以接口是否正常

表比较多，这里列举一个典型的多对多，角色和模型的例子进行说明

创建角色实体类，角色和模型是多对多，所以角色中应该包含模型的集合

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Role {

    private Integer id;
    private String roletype;
    private Date createAt;
    private String createBy;

    private List<Model> models;
}

创建模型实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Model {

    private Integer id;
    private String modelName;
    private String URL;
    private Date createAt;
    private String createBy;

创建角色接口，

public interface RoleMapper {

    //增加一个
    Integer addRole(Role role);

    //根据id删除一个
    Integer deleteRoleById(Integer id);


    //更新 回复一个
    boolean updateRole(Role role);

    //根据id查询,返回一个
    Role getRoleById(Integer id);

    //查询全部
    List<Role> queryAllRole();

编写service层

public interface RoleService {

    //增加一个一级标题
    Integer addRole(Role role);

    //根据id删除一个
    Integer deleteRoleById(Integer id);


    //更新 回复一个
    boolean updateRole(Role role);

    //根据id查询,返回一个
    Role getRoleById(Integer id);

    //查询全部,返回list集合
    List<Role> queryAllRole();

public class RoleServiceImpl implements RoleService{

    private RoleMapper roleMapper;

    public void setRoleMapper(RoleMapper roleMapper) {
        this.roleMapper = roleMapper;
    }

    @Override
    public Integer addRole(Role role) {
        return roleMapper.addRole(role);
    }

    @Override
    public Integer deleteRoleById(Integer id) {
        return roleMapper.deleteRoleById(id);
    }

    @Override
    public boolean updateRole(Role role) {
        return roleMapper.updateRole(role);
    }

    @Override
    public Role getRoleById(Integer id) {
        return roleMapper.getRoleById(id);
    }

    @Override
    public List<Role> queryAllRole() {
        return roleMapper.queryAllRole();
    }

编写接口配置文件

 <!--增加一个-->
 <insert id="addRole" parameterType="Role" useGeneratedKeys="true" keyProperty="id">
   insert into role(roletype,create_at,create_by)
   values (#{roletype} ,now(),#{createBy})
</insert>

 <!--根据id删除一个-->
 <delete id="deleteRoleById" parameterType="Integer">
   delete from role where id=#{id}
</delete>

 <!--修改/回复一个留言-->
 <update id="updateRole" parameterType="Role" >
     update role set roletype = #{roletype}, create_by = #{createBy} where id = #{id}
 </update>

 <!--根据id查询,返回一个-->
 <select id="getRoleById" resultType="Role">
   select * from role
   where id = #{id}
 </select>

 <!--查询全部-->
 <select id="queryAllRole" resultMap="RoleModel">
   SELECT r.id id,r.roletype roletype,m.model_name model_name
    FROM role r
      left outer join rolemodel rm on r.id = rm.r_id
        left outer join model m on m.id = rm.m_id
</select>

 <resultMap id="RoleModel" type="Role">
     <result  property="id" column="id"/>
     <result  property="roletype" column="roletype"/>
     <collection property="models" ofType="Model">
         <id  property="id" column="id"/>
         <result property="modelName" column="model_name" />
     </collection>
 </resultMap>

编写controller层

@Controller
@RequestMapping("role")
public class RoleController {

    Logger logger = Logger.getLogger(RoleController.class);

    @Autowired
    @Qualifier("RoleServiceImpl")
    private RoleService roleService;


    //添加一条留言
    @RequestMapping("/add")
    @ResponseBody
    public Map add(Role role) {

        Map<String, Object> map = new HashMap<String, Object>();
        int a = roleService.addRole(role);
        System.out.println(role);
        logger.info("=============="+a);

        map.put("code", 200);
        map.put("data", role);
        map.put("message", "添加成功");

        return map;

    }
    //删除一条留言
    @RequestMapping("/del/{id}")
    @ResponseBody
    public Map delete(@PathVariable("id") Integer id) {
        Map<String, Object> map = new HashMap<>();
        int i = roleService.deleteRoleById(id);
        if(i>0) {
            map.put("code", 200);
            map.put("message", "删除成功");

        }
        return map;
    }

    //回复一条留言
    @RequestMapping("/updateMess")
    @ResponseBody
    public Map update(Role role){
        roleService.updateRole(role);
        System.out.println(role);
        Map map = new HashMap<>();

        map.put("code", 200);
        map.put("message","修改成功");
        map.put("data",role);

        return map;
    }

    //查询一条
    @RequestMapping("/sel/{id}")
    @ResponseBody
    public Map getById(@PathVariable("id") Integer id){

        Map map = new HashMap<>();
        Role role = roleService.getRoleById(id);

        map.put("code", 200);
        map.put("message","查询成功！！！！");
        map.put("data",role);
        return map;
    }

    //查询全部
    @RequestMapping("/all")
    @ResponseBody
    public Map Map(){

        Map map = new HashMap<>();
        List<Role> list = roleService.queryAllRole();

        map.put("code", 200);
        map.put("message","查询成功！！！！");
        map.put("data",list);
        return map;
    }

postman测试

今天计划的事：使用Nginx

遇到的困难：

收获：