精华内容
下载资源
问答
  • 2020-11-30 02:01:34

    简单提供几个思路。

    比较常见的做法是通过训练词向量,计算词向量的相似度。正如题主所说的word2vec就是最常见的是训练词向量的方法。

    word2vec是Google的一个开源工具,通过将词转化成向量的形式,可以把对文本內容的处理简化为向量空间中的向量运算,往往会结合余弦相似度来计算向量空间上的相似度,來表示文本语意上的相似度。

    例如:

    word2vec训练词向量的方法是通过上下文去预测某个词或者通过一个词去预测上下文,所以除了得到语义相近的词,往往还会得到搭配比较多的关联词。所以word2vec是可行的。同理,其他训练词向量的方法也是可以的,比如glove或者fasttext等。而对于计算相似度的方法就更多了,就不概述了。

    还有通过句子结构分析和词与词之间的事理关系也是可以得到一些关联词,比如存在“不仅A而且B”这种句式时,A和B是很有可能是关联词,甚至是近义词。除了并列,还有顺承,转折等关系也是可以寻找关联词的。

    只从词本身看,有时候研究词与词的共现关系或者根据相同上下文相邻词的频数也可以挖掘关联词。

    更多相关内容
  • 为了解决传统文本表示方法袋模型对文本语义的忽略问题,提出种融合关联关系和统计信息的短文本建模方法。通过词语之间的内联及外联关系耦合得到词语关联关系,充分挖掘了显示和隐含的语义信息;同时以关联关系...
  • 该算法利用项间的关系丰富文本特征,通过定义项文档间关联关系项文档内关联关系揭示项间语义的关联程度,并由此自动生成有标记的数据来指导聚类过程。对项先验信息进行成对约束编码,构建基于项间成对...
  • 提出种基于关联关系与归一化割加权非负矩阵分解的微博用户兴趣模型构建方法。该方法首先基于分布上下文语义相关性来建立关联关系矩阵刻画项间相似度,然后应用归一化割加权非负矩阵分解算法获取用户—...
  • 提出了种基于关联词对动态抽取的报道关系检测方法。关联词对是指在同一篇报道中出现的满足一定关系约束的两个单词,而关系约束是指组特征的集合。该方法认为两篇报道中出现的相同的关联词对越多,两篇报道的...
  • 在多向量空间模型基础上提取不同向量的要素(时间、地点、人物和内容)特征词组成关联词对,使用支持向量机(SVM)方法整合关联词对相似度和余弦相似度,从而提出了种提取要素关联词对报道关系检测方法。所提方法补充...
  • 提出种基于关联关系与归一化割加权非负矩阵分解的微博用户兴趣模型构建方法。该方法首先基于分布上下文语义相关性来建立关联关系矩阵刻画项间相似度,然后应用归一化割加权非负矩阵分解算法获取用户—...
  • 「写论文」“常用关联词”汇总

    千次阅读 2019-05-28 18:12:48
    写论文、报告、项目书时,为了增强文章的结构性和行文的通顺性,应多使用关联词。小白把一些常用的关联词列举在下面,方便写文章时拿出来翻阅。 关联词共分成8类: 转折关系、假设关系、并列关系、递进关系、选择...

    写论文、报告、项目书时,为了增强文章的结构性和行文的通顺性,应多使用关联词。小白把一些常用的关联词列举在下面,方便写文章时拿出来翻阅。


    关联词共分成8类:

    转折关系、假设关系、并列关系、递进关系、选择关系、因果关系、条件关系、承接关系。

    1.转折关系

    • 虽然……但是……
    • 尽管……还是……
    • …… 却……
    • ……然而……
    • ……但是……
    • 虽然... ...却
    • 既然......也......

    2.假设关系

    • 如果……就……
    • 要是……那么......
    • 即便…...也……
    • 即使……也……
    • 倘若……就……
    • 要是……就……
    • 倘若.......便......

    3.并列关系

    • 一边……一边……
    • 一会儿…… 一会儿……
    • 既……又……
    • 又... ...又... ...
    • 一面.......一面...
    • 有……有……

    4.递进关系

    • 不但……而且……
    • 不光……也……
    • 不仅……还…
    • 不但不……反而……

    5.选择关系

    • 是……还是……
    • 要么……要么……
    • 或者......或者......
    • 与其……不如……
    • 宁可(宁愿)……也不(决不)……

    6.因果关系

    • 因为……所以……
    • 之所以……是因为……
    • 由于……因此……

    7.条件关系

    • 只要……就……
    • 只有……才……
    • 无论 (不论、不管、任凭)……都(也、还) 。
    • ……却……
    • ……是……是……

    8.承接关系

    • 一……就……
    • 首先……然后……
    • ……于是……
    • ……才……
    • ……接着……
    展开全文
  • 该方法首先利用TF-IEF和相邻合并策略对事件的相关报道集提取关键词,然后综合多种共现度量窗口对事件关键词的关联关系建模,构建事件关键词关联网络,最后依据事件间共有关键词的程度建立事件关联模型,从而建立...
  • 深入分析了概念、词汇和特征三者的内在关系,并在此基础上提出了种基于同义词汇的特征关联性,从文本中挖掘同义词集的算法。根据特征之间存在关联性的特点,算法以成熟的关联规则挖掘算法作为基础,获得了...
  • 离散数学-各种关联词的符号化

    千次阅读 2017-02-28 23:14:00
    离散数学--关联词的符号化问题 ①如果p那么q p->q; ②只有p才q q->p;(p是q的必要条件) 仔细想一下,只有p->q和q->p两种情况,p成立不一定q成立,而q成立,那么p一定成立,所以后者正确; ③只要pq ...

    离散数学--关联词符号化问题

    ①如果p那么q           p->q;

    ②只有p才q          q->p;(p是q的必要条件)

    仔细想一下,只有p->q和q->p两种情况,p成立不一定q成立,而q成立,那么p就一定成立,所以后者正确;

    ③只要p就q               p->q;(p是q的充分条件)  同①

    ④仅当p, q                 q->p(仅当不就是只有吗?)

    ⑤当且仅当p,q           q<->p(充要条件,与==等价)

    ⑥除非p 否则 q         非q->p

    (例:除非世界末日,否则我活着 》》 我死 -> 世界末日)

    只要 就-------充分条件

    只有 才-------必要条件

    暂时没有例子 

    展开全文
  • iBATIS一词来源于“internet”和“abatis”的组合,是个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects(DAO)。 MyBatis 是支持普通 SQL查询,存储过程和高级映射的优秀持久层...

    转载:https://www.cnblogs.com/tianlifitting/p/8583231.html

    1、什么是MyBatis?,

      MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis 。2013年11月迁移到Github。

      iBATIS一词来源于“internet”和“abatis”的组合,是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects(DAO)。

      MyBatis 是支持普通 SQL查询,存储过程和高级映射的优秀持久层框架。MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的 XML或注解用于配置和原始映射,将接口和 Java 的POJOs(Plain Ordinary Java Objects,普通的 Java对象)映射成数据库中的记录。

    2、MyBatis 入门实例基于xml配置

      ①、创建MySQL数据库:mybatisDemo和表:person

    1

    2

    3

    create database mybatisDemo;

    use mybatisDemo;

    create table person(pid int primary key AUTO_INCREMENT, pname varchar(50), page int);

      

         ②、建立一个Java工程,并导入相应的jar包

       

      相应的 jar 包下载链接:百度网盘-链接不存在  密码:nkt6

    ③、在 MyBatisDemo 工程中添加数据库配置文件 mybatis-configuration.xml,这一步按照自己项目框架结构进行自由配置!

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    <?xml version="1.0" encoding="UTF-8"?>

    <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

    <configuration>

    <!-- 可以配置多个运行环境,但是每个 SqlSessionFactory 实例只能选择一个运行环境  

      一、development:开发模式

       二、work:工作模式-->

     <environments default="development">

     <!--id属性必须和上面的default一样  -->

        <environment id="development">

        <!--事务管理器

            一、JDBC:这个配置直接简单使用了 JDBC 的提交和回滚设置。它依赖于从数据源得到的连接来管理事务范围

            二、MANAGED:这个配置几乎没做什么。它从来不提交或回滚一个连接。而它会让容器来管理事务的整个生命周期

                比如 spring 或 JEE 应用服务器的上下文,默认情况下,它会关闭连接。然而一些容器并不希望这样,

                因此如果你需要从连接中停止它,就可以将 closeConnection 属性设置为 false,比如:

                <transactionManager type="MANAGED">

                    <property name="closeConnection" value="false"/>

                </transactionManager>

          -->

          <transactionManager type="JDBC"/>

          <!--dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象源  -->

          <dataSource type="POOLED">

            <property name="driver" value="com.mysql.jdbc.Driver"/>

            <property name="url" value="jdbc:mysql://localhost:3306/mybatisdemo"/>

            <property name="username" value="root"/>

            <property name="password" value="root"/>

          </dataSource>

        </environment>

      </environments>

    </configuration>

    ④、定义表所对应的实体类

      

    ⑤、定义操作 person 表的sql映射文件personMapper.xml

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    <?xml version="1.0" encoding="UTF-8" ?>

    <!DOCTYPE mapper

      PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

      "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

    <mapper namespace="com.ys.bean.personMapper">

      <!-- 根据 pid 查询 person 表中的数据

           id:唯一标识符,此文件中的id值不能重复

           resultType:返回值类型,一条数据库记录也就对应实体类的一个对象

           parameterType:参数类型,也就是查询条件的类型

       -->

      <select id="selectPersonById"

                resultType="com.ys.bean.Person" parameterType="int">

        <!-- 这里和普通的sql 查询语句差不多,对于只有一个查询条件后面的 #{pid}表示占位符,里面不一定要写pid,写啥都可以,但是不要空着;如果有多个查询条件,则要写pojo类里面的属性 -->

        select * from person where pid = #{pid}

      </select>

       

      <!-- 查询person 表所有数据 -->

      <select id="getAllPerson" resultType="com.ys.bean.Person">

        select * from person

      </select>

       

      <!-- 根据id更新数据 -->

      <update id="updatePersonById" parameterType="com.ys.bean.Person">

        update person set pname=#{pname},page=#{page} where pid = #{pid}

      </update>

       

      <!-- 向 person 表插入一条数据 -->

      <insert id="addPerson" parameterType="com.ys.bean.Person">

        insert into person(pid,pname,page) values(#{pid},#{pname},#{page})

      </insert>

       

      <!-- 根据 pid 删除数据 -->

      <delete id="deletePersonById" parameterType="Long">

        delete from person where pid=#{pid}

      </delete>

       

    </mapper>

      

      ⑥、向 mybatis-configuration.xml 配置文件中注册 personMapper.xml 文件

    1

    2

    3

    4

    5

    <mappers>

           <!-- 注册personMapper.xml文件,

           personMapper.xml位于com.ys.bean这个包下,所以resource写成com/ys/bean/personMapper.xml-->

           <mapper resource="com/ys/bean/personMapper.xml"/>

    </mappers>

      如下图所示:

       ⑦、创建测试类

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    62

    63

    64

    65

    66

    67

    68

    69

    70

    71

    72

    73

    74

    75

    76

    77

    78

    79

    80

    81

    82

    83

    84

    85

    86

    87

    88

    package com.ys.test;

    import java.io.InputStream;

    import java.util.List;

    import org.apache.ibatis.session.SqlSession;

    import org.apache.ibatis.session.SqlSessionFactory;

    import org.apache.ibatis.session.SqlSessionFactoryBuilder;

    import org.junit.Before;

    import org.junit.Test;

    import com.ys.bean.Person;

    public class MyBatisTest {

        SqlSession session;

         

        @Before

        public void beforeLoadXML(){

            //加载 mybatis 配置文件

            InputStream inputStream = MyBatisTest.class.

                    getClassLoader().getResourceAsStream("mybatis-configuration.xml");

            //构建sqlSession的工厂

            SqlSessionFactory sqlSessionFactory =

                    new SqlSessionFactoryBuilder().build(inputStream);

            //根据 sqlSessionFactory 产生 session

            session = sqlSessionFactory.openSession();

        }

         

        //根据 pid 查询 person 表中的数据

        @Test

        public void testSelectById(){

            //这个字符串有 personMapper.xml 文件中 两个部分构成

            //<mapper namespace="com.ys.bean.personMapper"> 的 namespace 的值

            //<select id="selectPersonById" > id 值

            String statement = "com.ys.bean.personMapper"+".selectPersonById";

            Person p = session.selectOne(statement, 1);

            System.out.println(p);

            session.close();

        }

         

        //查询person 表所有数据

        @Test

        public void testGetAllPerson(){

            String statement = "com.ys.bean.personMapper.getAllPerson";

            List<Person> listPerson = session.selectList(statement);

            System.out.println(listPerson);

            session.close();

        }

         

        //根据id更新数据

        @Test

        public void updateById(){

            String statement = "com.ys.bean.personMapper.updatePersonById";

            Person p = new Person();

            p.setPid(1);

            p.setPname("aaa");

            p.setPage(11);

            session.update(statement, p);

            session.commit();

            session.close();

        }

         

        //向 person 表插入一条数据

        @Test

        public void addPerson(){

            String statement = "com.ys.bean.personMapper.addPerson";

            Person p = new Person();

            //由于我们设置了主键的自增长机制,故这里不需要手动设置 pid 的值

            //p.setPid(1);

            p.setPname("add");

            p.setPage(11);

            session.insert(statement, p);

            session.commit();

            session.close();

        }

         

        //根据 pid 删除person 表中的数据

        @Test

        public void deletePersonById(){

            String statement = "com.ys.bean.personMapper.deletePersonById";

            session.delete(statement, 1);

            session.commit();

            session.close();

             

        }

         

    }

    4、MyBatis 入门实例  一对一  基于xml配置

      这里我们以老师和班级为例,假设一般班级只能拥有有一个老师,一个老师只能带一个班级。

      ①、创建实体类

      

       Teacher.java和Classes.java

     ②、在数据库中根据实体类创建相应的数据表

       ③、定义操作 Classes 表的sql映射文件classesMapper.xml 

    <?xml version="1.0" encoding="UTF-8" ?>

    <!DOCTYPE mapper

      PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

      "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

    <mapper namespace="one.to.one.classesMapper">

        <!--

             方式一:嵌套结果:使用嵌套结果映射来处理重复的联合结果的子集

                     封装联表查询的数据(去除重复的数据)

             select * from classes c, teacher t where c.tid=t.tid and c.tid=#{tid}

         -->

        <select id="getClasses" resultMap="getClassesMap" parameterType="int">

            select * from classes c ,teacher t

                where c.tid=t.tid and c.tid=#{tid}

        </select>

        <resultMap type="one.to.one.Classes" id="getClassesMap">

            <id column="cid" property="cid"/>

            <result column="cname" property="cname"/>

            <association property="teacher" javaType="one.to.one.Teacher">

                <id column="tid" property="tid"></id>

                <result column="tname" property="tname"/>

            </association>

        </resultMap>

        <!--

             方式二:嵌套查询:通过执行另外一个SQL映射语句来返回预期的复杂类型

             SELECT * FROM classes WHERE cid=1;

             SELECT * FROM teacher WHERE tid=1   //1 是上一个查询得到的tid的值

             property:别名(属性名)    column:列名 -->

              <!-- 把teacher的字段设置进去 -->

        <select id="getClasses2" resultMap="getClassesMap2">

            select * from classes c where c.cid = #{cid}

        </select>

        <resultMap type="one.to.one.Classes" id="getClassesMap2">

            <id column="cid" property="cid"/>

            <result column="cname" property="cname"/>

            <collection property="teacher" column="tid" select="getTeacherCollection">

            </collection>

        </resultMap>

        <select id="getTeacherCollection" resultType="one.to.one.Teacher">

            select tid tid,tname tname from teacher where tid=#{tid}

        </select>

       

    </mapper>

      说明:我们这里一对一的关联操作,有两种方式:

        1、使用嵌套结果映射来处理重复的联合结果的子集

        2、通过执行另外一个SQL映射语句来返回预期的复杂类型

        相关属性解释:

      ④、向 mybatis-configuration.xml 配置文件中注册 classesMapper.xml 文件

      

      ⑤、编写测试类

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    package one.to.one;

    import java.io.InputStream;

    import org.apache.ibatis.session.SqlSession;

    import org.apache.ibatis.session.SqlSessionFactory;

    import org.apache.ibatis.session.SqlSessionFactoryBuilder;

    import org.junit.Before;

    import org.junit.Test;

    import com.ys.test.MyBatisTest;

    public class OneToOneTest {

    SqlSession session;

         

        @Before

        public void beforeLoadXML(){

            //加载 mybatis 配置文件

            InputStream inputStream = MyBatisTest.class.

                    getClassLoader().getResourceAsStream("mybatis-configuration.xml");

            //构建sqlSession的工厂

            SqlSessionFactory sqlSessionFactory =

                    new SqlSessionFactoryBuilder().build(inputStream);

            //根据 sqlSessionFactory 产生 session

            session = sqlSessionFactory.openSession();

        }

         

        //一对一嵌套结果方式:根据班级id查询教师信息

        @Test

        public void testGetTeacher(){

            String statement = "one.to.one.classesMapper.getTeacher";

            Teacher t = session.selectOne(statement, 1);

            System.out.println(t);

        }

         

        //一对一嵌套查询方式:根据教师id查询班级信息

        @Test

        public void testGetClasses2(){

            String statement = "one.to.one.classesMapper.getClasses2";

            Classes c = session.selectOne(statement, 1);

            System.out.println(c);

        }

         

         

    }

      

    4、MyBatis 入门实例  一对多,多对一  基于xml配置

      这里我们以班级和学生为例,一个班级里面对应多个学生,这是一对多;反过来,多个学生对应一个班级,这是多对一

      ①、建立学生和班级的实体类

      Student.java

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    package one.to.many;

    public class Student {

        private int sid;

        private String sname;

        private Classes classes;

        public int getSid() {

            return sid;

        }

        public void setSid(int sid) {

            this.sid = sid;

        }

        public String getSname() {

            return sname;

        }

        public void setSname(String sname) {

            this.sname = sname;

        }

        public Classes getClasses() {

            return classes;

        }

        public void setClasses(Classes classes) {

            this.classes = classes;

        }

        @Override

        public String toString() {

            return "Student [sid=" + sid + ", sname=" + sname + ", classes=" + classes + "]";

        }

         

    }

        Classes.java

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    package one.to.many;

    import java.util.Set;

    public class Classes {

        private int cid;

        private String cname;

        private Set<Student> students;

         

        public int getCid() {

            return cid;

        }

        public void setCid(int cid) {

            this.cid = cid;

        }

        public String getCname() {

            return cname;

        }

        public void setCname(String cname) {

            this.cname = cname;

        }

        public Set<Student> getStudents() {

            return students;

        }

        public void setStudents(Set<Student> students) {

            this.students = students;

        }

        @Override

        public String toString() {

            return "Classes [cid=" + cid + ", cname=" + cname + ", students=" + students + "]";

        }

    }

      

      ②、在数据库中根据实体类创建相应的数据表

      ③、多对一:定义操作 Classes 表的sql映射文件classesMapper.xml 

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    <?xml version="1.0" encoding="UTF-8" ?>

    <!DOCTYPE mapper

      PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

      "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

    <mapper namespace="one.to.many.classesMapper">

        <select id="getClasses" resultMap="getClassesMap">

            select * from classes c,student s where s.cid=c.cid and c.cid=#{cid}

        </select>

        <resultMap type="one.to.many.Classes" id="getClassesMap">

            <id column="cid" property="cid"></id>

            <result column="cname" property="cname"/>

            <collection property="students" ofType="one.to.many.Student">

                <id column="sid" property="sid"/>

                <result column="sname" property="sname"/>

            </collection>

        </resultMap>

         

    </mapper>

      ④、一对多:定义操作 Student 表的sql映射文件studentMapper.xml

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    <?xml version="1.0" encoding="UTF-8" ?>

    <!DOCTYPE mapper

      PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

      "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

    <mapper namespace="many.to.one.studentMapper">

        <select id="getStudents" resultMap="getStudentMap">

            select * from classes c,student s where s.cid=c.cid and s.sid=#{sid}

        </select>

        <resultMap type="one.to.many.Student" id="getStudentMap">

            <id column="sid" property="sid"></id>

            <result column="sname" property="sname"/>

            <association property="classes" javaType="one.to.many.Classes">

                <id column="cid" property="cid"/>

                <result column="cname" property="cname"/>

            </association>

        </resultMap>

         

    </mapper>

      ⑤、向 mybatis-configuration.xml 配置文件中注册 classesMapper.xml 、studentMapper.xml文件

      ⑥、编写测试类

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    package one.to.many;

    import java.io.InputStream;

    import org.apache.ibatis.session.SqlSession;

    import org.apache.ibatis.session.SqlSessionFactory;

    import org.apache.ibatis.session.SqlSessionFactoryBuilder;

    import org.junit.Before;

    import org.junit.Test;

    import com.ys.test.MyBatisTest;

    public class OneToManyTest {

    SqlSession session;

         

        @Before

        public void beforeLoadXML(){

            //加载 mybatis 配置文件

            InputStream inputStream = MyBatisTest.class.

                    getClassLoader().getResourceAsStream("mybatis-configuration.xml");

            //构建sqlSession的工厂

            SqlSessionFactory sqlSessionFactory =

                    new SqlSessionFactoryBuilder().build(inputStream);

            //根据 sqlSessionFactory 产生 session

            session = sqlSessionFactory.openSession();

        }

         

        //一对多嵌套结果方式:根据班级id查询班级所有的学生信息

        @Test

        public void testGetClasses(){

            String statement = "one.to.many.classesMapper.getClasses";

            Classes c = session.selectOne(statement, 1);

            System.out.println(c);

            System.out.println(c.getStudents().size());

        }

         

         

        //多对一嵌套结果方式:根据学生id查询班级信息

        @Test

        public void testGetStudents(){

            String statement = "many.to.one.studentMapper.getStudents";

            Student s = session.selectOne(statement, 1);

            System.out.println(s);

            System.out.println(s.getClasses());

        }

         

         

    }


    5、MyBatis 入门实例  多对多  基于xml配置

      这里我们以 users 表和 groups 表为例,一个 users 可能加入多个 groups,而一个 groups 可能包含多个 users,故构成 多对多 的关联

      ①、在数据库中建立相应的表

      users 表

      

      groups 表

      

      两者之间的关联表users_groups表

      

      ②、建立对应的实体类

      Users.java

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    package many.to.many;

    import java.util.Set;

    public class Users {

        private int uid;

        private String uname;

        private Set<Groups> groups;

        public int getUid() {

            return uid;

        }

        public void setUid(int uid) {

            this.uid = uid;

        }

        public String getUname() {

            return uname;

        }

        public void setUname(String uname) {

            this.uname = uname;

        }

        public Set<Groups> getGroups() {

            return groups;

        }

        public void setGroups(Set<Groups> groups) {

            this.groups = groups;

        }

        @Override

        public String toString() {

            return "User [uid=" + uid + ", uname=" + uname + ", groups=" + groups + "]";

        }

         

    }

        Groups.java

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    package many.to.many;

    import java.util.Set;

    public class Groups {

        private int gid;

        private String gname;

        private Set<Users> users;

        public int getGid() {

            return gid;

        }

        public void setGid(int gid) {

            this.gid = gid;

        }

        public String getGname() {

            return gname;

        }

        public void setGname(String gname) {

            this.gname = gname;

        }

        public Set<Users> getUsers() {

            return users;

        }

        public void setUsers(Set<Users> users) {

            this.users = users;

        }

        @Override

        public String toString() {

            return "Group [gid=" + gid + ", gname=" + gname + ", users=" + users + "]";

        }

         

    }

        Users_Groups.java

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    package many.to.many;

    public class Users_Groups {

        private Users user;

        private Groups group;

        public Users getUser() {

            return user;

        }

        public void setUser(Users user) {

            this.user = user;

        }

        public Groups getGroup() {

            return group;

        }

        public void setGroup(Groups group) {

            this.group = group;

        }

    }

      ③、多对多:定义操作 sql映射文件userMapper.xml

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    <?xml version="1.0" encoding="UTF-8" ?>

    <!DOCTYPE mapper

      PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

      "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

    <mapper namespace="many.to.many.userMapper">

        <!-- 给一个用户 id,查看该用户下的所有用户组信息 -->

        <select id="getUsers" resultMap="getGroupMap">

            select g.gid,g.gname from users_groups ug,groups g

                where ug.group_id=g.gid and ug.user_id=#{uid}

        </select>

        <resultMap type="many.to.many.Groups" id="getGroupMap">

            <id column="gid" property="gid"/>

            <result column="gname" property="gname"/>

            <collection property="users" ofType="many.to.many.Users">

                <id column="uid" property="uid"/>

            <result column="uname" property="uname"/>

            </collection>

        </resultMap>

         

    </mapper>

      

      ⑤、向 mybatis-configuration.xml 配置文件中注册 userMapper.xml文件

      ⑥、编写测试类

    1

    2

    3

    4

    5

    6

    7

    8

    9

    //多对多:根据根据用户 id 查询所有的用户组信息

        @Test

        public void testGetGroups(){

            String statement = "many.to.many.userMapper.getUsers";

            List<Groups> listGroup = session.selectList(statement,1);

            for(Groups g : listGroup){

                System.out.println(g.toString());

            }

        }

      

    ④、定义表所对应的实体类

      

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    package com.ys.bean;

    public class Person {

        private int pid;

        private String pname;

        private int page;

         

        public int getPid() {

            return pid;

        }

        public void setPid(int pid) {

            this.pid = pid;

        }

        public String getPname() {

            return pname;

        }

        public void setPname(String pname) {

            this.pname = pname;

        }

        public int getPage() {

            return page;

        }

        public void setPage(int page) {

            this.page = page;

        }

        @Override

        public String toString() {

            return "Person [pid=" + pid + ", pname=" + pname + ", page=" + page

                    "]";

        }

    }

    展开全文
  • 展开全部组合关系是指个单位和同一e5a48de588b662616964757a686964616f31333431363030序列的其他单位间的关系,或共现的所有成分的关系处于组合关系必须满足一些句法和语义条件。组合关系也称句段关系,可比作...
  • mysql指引():mysql到底是什么

    千次阅读 2020-01-13 21:06:15
    主要讲mysql是什么,重点理清“关系”这个概念
  • 多对多关系的多表关联查询

    万次阅读 多人点赞 2017-11-23 19:14:20
    1.什么是多对多关系   多对多关系 (百度): 多对多关系关系数据库中两个表之间的关系, 该关系中第个表中的个行可以与第二个表中的个或多个行相关。第二个表中的个行也可以与第个表中的个或...
  • 首先定义了文本中汉字与汉字之间关系的量化方法,提出汉字关联度的概念,然后构造汉字关联度矩阵来表示汉语文本,并设计了种基于汉字关联度矩阵的汉语文本相似性度量算法。实验结果表明,汉字关联度优于二字词频...
  • UML关联关系

    千次阅读 2012-07-06 10:49:53
    UML中的关联关系其内在意思就是has a 相对于依赖关系,关联关系在代码中有所体现.上图中的关联关系在代码中体现为 其中water 中将Climate作为其中的属性. 当然,关联关系中也有双相关联     关联又分为组合,...
  • 助记什么,有什么用?

    千次阅读 2019-02-04 19:36:34
    助记什么,有什么用?    玩加密货币的朋友相信对助记都不陌生,我们在使用钱包之前,会让你备份12个单词,在备份期间不允许截图操作,并且不断强调这12个单词非常重要,最好用物理方式备份,备份时身边...
  • 关于 csdn 上有个同行做了详细的分析,写的很不错。我这里懒了,直接转过来作为备份。 用C++程序的话,聚合像是类中的指针成员,而组合就是类中的成员. 类间关系 在类图中,除了需要描述单独的类的名称、属性...
  • 本篇文章主要采用Python和Gephi构建中国知网某个领域的作者合作关系和主题共现的知识图谱,重点阐述了种可操作的关系图谱构建方法,可用于论文发表、课程或企业可视化展示等。其基本步骤如下:1.在中国知网搜索...
  • SCI论文写作中常用的连接和短语

    千次阅读 2021-12-27 21:20:05
    SCI-关联词 SCI论文写作中常用的连接词和短语。 描述相似性连词 英文 中文 Likewise 同样地 Correspondongly 相应地 Equally 同样地 Not only…but also 不仅…而且 In the same way 以同样的方式 ...
  • NLP系列(10)_向量之图解Word2vec

    万次阅读 多人点赞 2019-04-08 09:58:35
    审校:龙心尘 作者:Jay Alammar 编译:张秋玥、毅航、高延 ...原文链接: https://jalammar.github.io/illustrated-word2vec/ 嵌入(embedding)是机器学习中最迷人的想法之。 如果你曾经使用Siri、Google...
  • 导读:大数据、人工智能是目前大家谈论比较多的话题,它们的应用也越来越广泛、与我们的生活关系也越来越密切,影响也越来越深远,其中很多已进入寻常百姓家,如无人机、网约车、自动...
  • 展开全部组合关系也称62616964757a686964616fe4b893e5b19e31333431343632句段关系,可比作横向水平关系,指个语言元素与另语言元素同时排列在言语链条上,构成语言要素在现场的组合,如在“快来”这个句子中,...
  • Elasticsearch文档内部的父子关系

    千次阅读 2021-11-20 10:59:42
    Elasticsearch中的父子关系是单个索引内部文档与文档之间的关系,父文档与子文档同属个索引并通过父文档id建立联系, 类似于关系型数据库中单表内部行与行之间的自关联,比如有层级关系的部门表中记录之间的...
  • 常用分析方法——矩阵关联分析

    千次阅读 2021-01-06 23:31:33
    、矩阵关联分析(象限分析法) 定义 将事物的两个重要指标作为分析的依据,进行分类关联分析,找出解决问题的种分析方法,也称为矩阵关联分析法,简称矩阵分析(或象限分析)。 作用 (1)将有相同特征的事件...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 88,809
精华内容 35,523
关键字:

一就关联词是什么关系