MyBatis纯注解的一对一,一对多,多对多

一对一

用户 和 卡

用户 User

public class User {
    private Integer uid;
    private String uname;
    private String pass;
    //用户对应的卡 
    private Card card;

	//对应的构造方法，tostring方法，get，set方法
	
}

卡 Card

public class Card {
    private Integer uid;
    private String number;
    
    //卡对应的用户
    private User user;

	//对应的构造方法，tostring方法，get，set方法
}

User的接口

public interface UserMapper {
    //查询全部的用户
    @Select("select * from user")
    //多个结果集 可能一张表和多个表有关系
    @Results({
            @Result(property = "uid",column = "uid",id=true),
            /*property：实体类中对应的对象名
            column：与哪一列连接
            one=@One(select="包名加类名加方法")：关系中一对一的一来自一个接口中方法的查询,是根据用户id查询对应的卡
            */
            @Result(property = "card",column = "uid",one=@One(select="com.ywy.mapper.CardMapper.findCardById"))
    })
    public List<User> findAllUser();

    //查询指定用户，就把用户对应的卡查询出来
    @Select("select * from user where uid=#{uid}")
    @Results({//有可能用户表和多个表有多个关系
        //property:实体类中对应的字段
        //colimn:通过哪一个字段查询
        //one=@One(select=""):一对一的一来自哪里
        @Result(property = "uid",column = "uid",id = true),
        @Result(property =  "card",column="uid",one=@One(select="com.ywy.mapper.CardMapper.findCardById"))
})
     public User findUserById(int uid);	



}

然后CardMapper中

public interface CardMapper {
	//根据用户id查询卡号
@Select("select * from card where uid=#{uid}")
@Results({
        @Result(property = "uid",column = "uid",id=true),
        @Result(property = "user",column = "uid",one=@One(select="com.ywy.mapper.UserMapper.findUserById"))
})
public Card findCardById(int uid);



//查询全部的卡和对应的用户
@Select("select * from card")
@Results({
        @Result(property = "uid",column = "uid",id=true),
        @Result(property = "user",column = "uid",one=@One(select="com.ywy.mapper.UserMapper.findUserById"))
})
public List<Card> findAllUser();

}

测试类中

//查询用户和用户对应的卡
/*User user = umapper.findUserById(1);
System.out.println(user);
System.out.println(user.getCard().getNumber());*/

一对多

省份 和 城市

省份实体类

public class Province {
    private Integer pid;
    private String pname;
    
    //省份里面的城市
    private List<City> cities;
    
    //get,set方法，tostring，构造方法
    
}

城市类

public class City {
    private Integer cid;
    private String cname;
    private Integer pid;
    //城市里面的省份
    private Province province;
    //get,set方法，tostring，构造方法
}

省份的接口

public interface ProvinceMapper {
    //查询省份和省份下面所有的城市
    @Select("select * from province")
    @Results(value = {
            @Result(property = "pid",column = "pid",id = true),
            @Result(property = "cities",column = "pid",many=@Many(select="com.ywy.mapper.CityMapper.findCityById"))
    })
    public List<Province> findAllProvince();
    
    //根据省份id查询省份和对应城市
    @Select("select * from province where pid=#{pid}")
    @Results({
            @Result(property = "pid",column = "pid",id=true),
            @Result(property = "cities",column = "pid",many=@Many(select="com.ywy.mapper.CityMapper.findCityById"))
    })
    public Province findProvinceById(int pid);
}
	

City的接口

public interface CityMapper {
	//根据省份id查询城市
    @Select("select * from city where pid=#{pid}")
    public City findCityById(int pid);
    
     //通过城市查询省份
    @Select("select * from city")
    @Results({
            @Result(property = "cid",column = "cid",id=true),
            @Result(property = "province",column = "pid",one=@One(select="com.ywy.mapper.ProvinceMapper.findProvinceById"))
    })
    public List<City> findAllCity();
    //查询单个城市和对应的省份
    @Select("select * from city where cid=#{cid}")
    @Results({
            @Result(property = "cid",column = "cid",id=true),
            @Result(property = "province",column = "pid",one=@One(select="com.ywy.mapper.ProvinceMapper.findProvinceById"))
    })
    public City findCityByCid(int cid);
}

测试一对多

ProvinceMapper pmapper=session.getMapper(ProvinceMapper.class);
//查询所有的省份和对应的城市
List<Province> plist=pmapper.findAllProvince();
for (Province province : plist) {
    System.out.println(province.getPname());
    for (City city : province.getCities()) {
        System.out.println("城市    "+city.getCname());
    }
}

多对多

老师 和 同学

学生实体类Student

public class Student {
    private Integer sid;
    private String name;
    private String sex;
    private Integer age;
    private Date time;
    //学生里面的老师集合
private List<Teacher> teachers;

	//get，set方法，tostring方法，构造方法

}

StudentMapper学生的接口

public interface StudentMapper {
    //查询全部的学生
    @Select("select * from student")
    @Results({
            @Result(property = "sid",column = "sid",id=true),
            @Result(property = "teachers",column = "sid",many=@Many(select="com.ywy.mapper.TeacherMapper.findTeacherBySid"))
    })
    public List<Student> findAllStudent();

    //查询学生的老师
    @Select("select * from student s inner join stu_tea st on s.sid=st.sid where st.tid=#{tid}")
    public Student findTeacherByTid(int tid);
}

老师的实体类
Teacher

public class Teacher {
    private Integer tid;
    private String tname;
    
    //老师里面的学生集合
    private List<Student> students;
//get，set方法，tostring方法，构造方法
}

老师的接口TeacherMapper

public interface TeacherMapper {
    //查询学生的老师
    @Select("select * from teacher t inner join stu_tea st on t.tid=st.tid where st.sid=#{sid}")
    public List<Teacher> findTeacherBySid(int sid);
    
    //查询老师和对应的老师
    @Select("select * from teacher")
    @Results({
            @Result(property = "tid",column = "tid",id=true),
            @Result(property = "students",column = "tid",many=@Many(select="com.ywy.mapper.StudentMapper.findTeacherByTid"))
    })
    public List<Teacher> findAllTaecher();
}

测试多对多

/查询老师和对应的学生
TeacherMapper tmapper=session.getMapper(TeacherMapper.class);
List<Teacher> tlist=tmapper.findAllTaecher();
for (Teacher teacher : tlist) {
    System.out.println(teacher.getTname());
    for (Student student : teacher.getStudents()) {
        System.out.println("学生    "+student.getName());
    }
}