精华内容
下载资源
问答
  • 两张表如何不使用外键,用中间表的方式建立一多多的关联关系,求大神解答
  • 实 验: 数据库及数据库中表的建立实验 一、实验目的 1.数据库的服务操作命令 (1)熟悉上机环境MySQL以及Navicat。 (2)掌握如何启动MySQL服务以及登录MySQL的方法。 2.数据库、表的创建 (1)理解并掌握...

     数据库及数据库中表的建立实验  

    一、实验目的

    1.数据库的服务操作命令

    (1)熟悉上机环境MySQL以及Navicat。

    (2)掌握如何启动MySQL服务以及登录MySQL的方法。

    2.数据库、表的创建

    (1)理解并掌握数据库中的一些基本概念,包括:数据库的定义、数据表的定义和数据类型等。

    (2)理解并掌握关系型数据库标准SQL语言。

    (3)掌握并熟练使用数据库,表的创建语句。

    3.数据库完整性

    (1)理解关系数据库三类完整性约束的基本概念。

    (2)掌握实现实体完整性、参照完整性、用户自定义完整性的方法。

    4.数据库的安全性

    (1)掌握数据库安全性的概念。

    (2)MySql数据库的安全性需要通过账户管理来保证,掌握MySql提供的语句进行创建用户、删除用户和权限管理的操作。

    二、实验内容

    1.熟悉上机环境。

    2.建立学生-课程数据库

    其中包括以下三个表:

    学生表:Student(Sno,Sname,Ssex,Sage,Sdept)

    课程表:Course(Cno,Cname,Cpno,Ccredit)

    学生选课表:SC(Sno,Cno,Grade)

    Student

    学号Sno

    姓名Sname

    性别Ssex

    年龄Sage

    所在系Sdept

    201215121

    李勇

    20

    CS

    201215122

    刘晨

    19

    CS

    201215123

    王敏

    18

    MA

    201215125

    张立

    19

    IS

    Course

    课程号Cno

    课程名Cname

    先行课Cpno

    学分Ccredit

    1

    数据库

    5

    4

    2

    数学

     

    2

    3

    信息系统

    1

    4

    4

    操作系统

    6

    3

    5

    数据结构

    7

    4

    6

    数据处理

     

    2

    7

    PASCAL语言

    6

    4

    SC

    学号Sno

    课程号Cno

    成绩Grade

    201215121

    1

    92

    201215121

    2

    85

    201215121

    3

    88

    201215122

    2

    90

    201215122

    3

    80

    3.实现上述关系数据库的整体性约束。

    4.安全性控制——用户和权限控制:

    (1)创建名为xxxxxxxxxxx,密码为xxx的用户;

    (2)授予用户名为xxxxxxxxxxx,密码为xxx的用户使用所有数据库stu的所有权限,并允许他向其他人授予这些权限;

    (3)撤销用户xxxxxxxxxxx的所有权限;

    (4)将用户名为xxxxxxxxxxx的用户重命名为xxx;

    (5)删除用户名为xxx的用户。

    三、实验环境

    (1)Windows10系统

    (2)MySQL5.7

    (3)Navivcat MySQL:一个MySQL数据库服务器管理和开发工具。

    四、实验前准备

    (1)提前在自己的笔记本电脑上将实验所需环境安装好。

    下载MySQL5.7-->安装-->配置环境变量-->下载安装Navicat for MySQL。

    (2)理解并掌握数据库的基本概念。

    A.数据库(Database):是按照数据结构来组织、存储和管理数据的仓库,是存储在一起的相关数据的集合。

    B.数据库系统(DataBase System,DBS):是采用数据库技术的计算机系统,是由数据库(数据)、数据库管理系统(软件)、数据库管理员(人员)、硬件平台(软件)5部分构成的运行实体。

    C.数据库管理系统(DataBase Management System,DBMS):是数据库管理系统的一个重要组成部分,是位于用户与操作之间的一层数据管理软件,负责数据库中的数据组织、数据操纵、数据维护和数据服务等。

    D.数据库常用对象:

    表:是包含数据库中所有数据的数据库对象,由行和列组成,用于组织和存储数据。

    字段:表中每列称为一个字段。

    (3)预习MySQL数据库的基本操作语句以及数据库完整性的实现方法。

    (4)预习数据库安全性控制的措施及实现。

    五、实验步骤及实验结果

    1、MySQL服务的操作命令(命令行输入):

    service mysql start|stop|restart|status

    start:启动服务

    stop:停止服务

    restart:重启服务

    status:查看服务状态

    (1)启动与关闭mysql服务器:

    启动:net start mysql

    退出:exit

    (2)连接服务器:

    mysql -uroot -pmysql

    2、数据库、表的创建

    (Navicat命令列界面,由于其环境限制,截图有一些不清晰)

    (1)查看当前服务器上管理的所有数据库:

    mysql>show databases; 

    (2)创建数据库:

    mysql>create database 库名; 

    数据库创建好后,可以使用show create database 库名;声明查看数据库 的定义。

    (3)选择数据库:

    mysql>use 库名;

    (4)查看当前选择的数据库:

    mysql> select database(); 

    (5)创建表

    注意:在创建表之前,应该先选择数据库。

    create table <表名>(

    字段名1,数据类型 [列级别约束条件] [默认值],

    字段名2,数据类型 [列级别约束条件] [默认值],

    .......

    );

    常见属性含义:

    PRIMARY KEY :主键;

    unique :唯一;

    not null/null :非空/空;

    AUTO_INCREMENT :自动加载;

    default :如果没有填写自动补写默认信息。

    A.表student

    a.创建:

    b.表结构

    B.表course

    a.创建

    b.表结构

    C.表SC

    a.创建:

    b.表结构:

    3、关系的完整性(Navicat命令列界面)

    (1)实体完整性——主键约束

    主键:能够唯一地标识表中地一条记录。

    要求:主键列的数据唯一,并且不允许为空。

    分类:单字段主键/多字段联合主键。

    A.单字段主键

    a.在定义列的同时指定主键:

    字段名 数据库类型 PRIMARY KEY [默认值]

    例:sno char(9) primary key, /*列级完整性约束条件,sno是主码*/

    b.在定义完所有列之后指定主键:

    [constraint <约束名>] primary key [字段名]

    例:primary key(sno)

    注意:

    如果发现主键设置错了,第一步,先删除主键:alter table student drop primary key;第二步,再增加主键:alter table student add primary key(sno);

    B.多字段联合主键

    primary key [字段1,字段2,......,字段n]

    例:PRIMARY KEY(sno,cno)

    (2)参照完整性——外键约束

    外键:一个表可以有一个或多个外键。其对应的是参照完整性,一个表的外键可以为空值,若不为空值,则每一个外键值必须等于另一个表中主键的某个值。

    注意:定义外键后,不允许删除在另一个表中具有关联关系的行。

    作用:保持数据的一致性、完整性。

    主表(父表):对于两个具有关联关系的表而言,相关联字段中主键所在的那个表。

    从表(子表):对于两个具有关联关系的表而言,相关联字段中外键所在的那个表。

    A.创建外键:

    [CONSTRAINT <外键名> ] FOREIGN KEY 字段名1 [,字段名2,...]

    REFERENCES <主表名> 主键列1 [,主键列2,...]

    注意:一个表中不能有相同名称的外键。

    说明:参照表与被参照表可以是同一个表。

    外键:

    B.为已经添加好的数据表添加外键:

    alter table 表名 add constraint FK_ID foreign key(你的外键字段名) REFERENCES 外表表名(对应的表的主键字段名);

    例: alter table tb_active add constraint FK_ID foreign key(user_id) REFERENCES tb_user(id);

    (3)用户自定义完整性——以非空约束为例

    创建课程course信息表,并为其cname字段添加非空约束,代码如下:

    表的结构如下所示:

    4.安全性

    (1)创建用户CREATE USER:

    创建名为xxxxxxxxxxx,密码为xxx的用户:

    (2)权限授予GRANT:

    授予用户名为xxxxxxxxxxx,密码为xxx的用户使用所有数据库stu的所有权限,并允许他向其他人授予这些权限:

    (3)撤销权限REVOKE:

    撤销用户xxxxxxxxxxx的所有权限:

    (4)重命名用户RENAME USER:

    将用户名为xxxxxxxxxxx的用户重命名为xxx:

    (5)删除用户DROP USER:

    删除用户名为xxx的用户:

     

     

     

    展开全文
  • dao接口: 测试类: 执行。 查询成功! 其他地方如何使用上面dao接口中的注解?

    dao接口中:
    在这里插入图片描述
    测试类中:
    在这里插入图片描述
    执行。在这里插入图片描述
    查询成功!

    其他地方如何使用上面dao接口中的注解?

    在这里插入图片描述

    展开全文
  • 在设计一个Javabean的时候,要把这些BEAN 的数据存放在数据库中的表结构,然而这些数据库中的表直接又有些特殊的关系,例如员工与部门直接有一对多的关系,学生与老师直接又多对多的关系,那么这些表的关系如何表示...

    黑马程序员

    我们知道,在设计一个Java bean的时候,要把这些BEAN 的数据存放在数据库中的表结构,然而这些数据库中的表直接又有些特殊的关系,例如员工与部门直接有一对多的关系,学生与老师直接又多对多的关系,那么这些表的关系如何表示呢?
    首先在建立数据库的时候就应该建立这样的对应关系。
    一对多 ,只要建立两个表就能建立这样的关系,因为你可以把多方的那个表设置一个Foreign Key 属性 ,下面是一个部门和员工的表结构关系
    MySQL 数据库上应该这样建立表结构:

    create table department(
    id int primary key,
    name varchar(100)
    );
    
    create table employee(
    id int primary key,
    name varchar(100),
    salary float(8,2),
    dept_id int,
    constraint dept_id_fk foreign key (dept_id) references department(id)//这个其实是约束条件,不是表格的属性值。
    );
    

      在java 程序的javabean中应该如何做呢 

    public class Department {
        private Integer id;
        private String name;
        private Set<Employee> emps = new HashSet<Employee>(); //????????????????????????????Set????
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Set<Employee> getEmps() {
            return emps;
        }
    
        public void setEmps(Set<Employee> emps) {
            this.emps = emps;
        }
    
        @Override
        public String toString() {
            return "Department [emps=" + emps + ", id=" + id + ", name=" + name +
            "]";
        }
    }
    
    
    public class Employee {
        private Integer id;
        private String name;
        private Float salary;
    
        // private Department dept = new Department();
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Float getSalary() {
            return salary;
        }
    
        public void setSalary(Float salary) {
            this.salary = salary;
        }
    
        @Override
        public String toString() {
            return "Employee [id=" + id + ", name=" + name + ", salary=" + salary +
            "]";
        }
    }
    

      在DAO层 如何实现增加 查询数据呢?增加一个部门和查询一个部门的时候要不要显示员工呢?

    public class DeparmentDao {
        private QueryRunner qr = new QueryRunner(JdbcUtil.getDataSource());
    
        public void addDepartment(Department dept) {
            try {
                //??????????
                String sql = "insert into department values(?,?)";
                Object[] params = { dept.getId(), dept.getName() };
                qr.update(sql, params);
    
                //???????????????????
                Set<Employee> emps = dept.getEmps();
    
                if ((emps != null) && (emps.size() > 0)) {
                    for (Employee e : emps) {
                        sql = "insert into employee values(?,?,?,?)";
                        params = new Object[] {
                                e.getId(), e.getName(), e.getSalary(), dept.getId()
                            };
                        qr.update(sql, params);
                    }
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    
        //??????????????????
        public List<Department> findDepts(boolean lazy) {
            try {
                //???????
                String sql = "select * from department";
                List<Department> depts = qr.query(sql,
                        new BeanListHandler<Department>(Department.class));
    
                if ((depts != null) && (depts.size() > 0)) {
                    for (Department dept : depts) {
                        if (lazy) {
                            //??
                            sql = "select id from employee where dept_id=?";
                        } else {
                            //??
                            sql = "select * from employee where dept_id=?";
                        }
    
                        List<Employee> emps = qr.query(sql,
                                new BeanListHandler<Employee>(Employee.class),
                                dept.getId());
    
                        for (Employee e : emps) {
                            dept.getEmps().add(e);
                        }
                    }
                }
    
                return depts;
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    
        //??????????????????.????????
        public List<Department> findDepts() {
            return findDepts(true);
        }
    }
    

      

     

    多对多的关系

    下面以老师和学生的关系来说明这个结构
    数据库中:

    create table teacher(
    id int primary key,
    name varchar(100),
    salary float(8,2)
    );
    
    create table student(
    id int primary key,
    name varchar(100),
    grade varchar(100)
    );
    
    create table teacher_student(
    t_id int,
    s_id int,
    primary key(t_id,s_id),
    constraint t_id_fk foreign key(t_id) references teacher(id),
    constraint s_id_fk foreign key(s_id) references student(id)
    );
    

      如何写javabean 和 dao呢 ?

    public class Teacher {
        private Integer id;
        private String name;
        private Float salary;
        private Set<Student> stus = new HashSet<Student>();
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Float getSalary() {
            return salary;
        }
    
        public void setSalary(Float salary) {
            this.salary = salary;
        }
    
        public Set<Student> getStus() {
            return stus;
        }
    
        public void setStus(Set<Student> stus) {
            this.stus = stus;
        }
    }
    
    
    public class Student {
        private Integer id;
        private String name;
        private String grade;
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getGrade() {
            return grade;
        }
    
        public void setGrade(String grade) {
            this.grade = grade;
        }
    
        @Override
        public String toString() {
            return "Student [grade=" + grade + ", id=" + id + ", name=" + name +
            "]";
        }
    }
    
    
    public class TeacherDao {
        private QueryRunner qr = new QueryRunner(JdbcUtil.getDataSource());
    
        public void addTeacher(Teacher t) throws SQLException {
            //????????
            String sql = "insert into teacher values(?,?,?)";
            Object[] params = { t.getId(), t.getName(), t.getSalary() };
            qr.update(sql, params);
    
            //????????
            //?3??
            Set<Student> stus = t.getStus();
    
            if ((stus != null) && (stus.size() > 0)) {
                for (Student s : stus) {
                    sql = "insert into student values(?,?,?)";
                    params = new Object[] { s.getId(), s.getName(), s.getGrade() };
                    qr.update(sql, params);
                    sql = "insert into teacher_student values(?,?)";
                    params = new Object[] { t.getId(), s.getId() };
                    ;
                    qr.update(sql, params);
                }
            }
        }
    
        public List<Teacher> findTeacher(boolean lazy) throws SQLException {
            String sql = "select * from teacher";
            List<Teacher> ts = qr.query(sql,
                    new BeanListHandler<Teacher>(Teacher.class));
    
            if ((ts != null) && (ts.size() > 0)) {
                for (Teacher t : ts) {
                    if (lazy) {
                        sql = "select id from student where id in (select s_id from teacher_student where t_id=?)";
                    } else {
                        sql = "select * from student where id in (select s_id from teacher_student where t_id=?)";
                    }
    
                    List<Student> stus = qr.query(sql,
                            new BeanListHandler<Student>(Student.class), t.getId());
    
                    for (Student s : stus) {
                        t.getStus().add(s);
                    }
                }
            }
    
            return ts;
        }
    }
    

      工具表工具

    public class JdbcUtil {
        private static DataSource ds;
        private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
    
        static {
            try {
                InputStream in = JdbcUtil.class.getClassLoader()
                                               .getResourceAsStream("dbcpconfig.properties");
                Properties props = new Properties();
                props.load(in);
    
                BasicDataSourceFactory factory = new BasicDataSourceFactory();
                ds = factory.createDataSource(props);
            } catch (Exception e) {
                throw new ExceptionInInitializerError(e);
            }
        }
    
        public static DataSource getDataSource() {
            return ds;
        }
    
        public static Connection getConnection() throws SQLException {
            Connection conn = tl.get();
    
            if (conn == null) {
                conn = ds.getConnection();
                tl.set(conn);
            }
    
            return conn;
        }
    
        public static void startTransaction() throws SQLException {
            Connection conn = tl.get();
    
            if (conn == null) {
                conn = ds.getConnection();
                tl.set(conn);
            }
    
            conn.setAutoCommit(false);
        }
    
        public static void rollback() throws SQLException {
            Connection conn = tl.get();
    
            if (conn == null) {
                conn = ds.getConnection();
                tl.set(conn);
            }
    
            conn.rollback();
        }
    
        public static void commit() throws SQLException {
            Connection conn = tl.get();
    
            if (conn == null) {
                conn = ds.getConnection();
                tl.set(conn);
            }
    
            conn.commit();
            tl.remove();
        }
    
        public static void release(ResultSet rs, Statement stmt, Connection conn) {
            if (rs != null) {
                try {
                    rs.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
    
                rs = null;
            }
    
            if (stmt != null) {
                try {
                    stmt.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
    
                stmt = null;
            }
    
            if (conn != null) {
                try {
                    conn.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
    
                conn = null;
            }
        }
    }
    

      

    dbcpconfig.properties的文件 中内容
    #连接设置
    driverClassName=com.mysql.jdbc.Driver
    url=jdbc:mysql://localhost:3306/day15  #这个是你的数据库地址
    username=root #这个是你的用户名
    password=sorry # 这个是你 密码


    #<!-- 初始化连接 -->
    initialSize=10

    #最大连接数量
    maxActive=20

    #<!-- 最大空闲连接 -->
    maxIdle=6

    #<!-- 最小空闲连接 -->
    minIdle=3

    #<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
    maxWait=60000


    #JDBC驱动建立连接时附带的连接属性属性的格式必须为这样:[属性名=property;] 
    #注意:"user" 与 "password" 两个属性会被明确地传递,因此这里不需要包含他们。
    connectionProperties=useUnicode=true;characterEncoding=utf8

    #指定由连接池所创建的连接的自动提交(auto-commit)状态。
    defaultAutoCommit=true

    #driver default 指定由连接池所创建的连接的只读(read-only)状态。
    #如果没有设置该值,则“setReadOnly”方法将不被调用。(某些驱动并不支持只读模式,如:Informix)
    defaultReadOnly=

    #driver default 指定由连接池所创建的连接的事务级别(TransactionIsolation)。
    #可用值为下列之一:(详情可见javadoc。)NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
    defaultTransactionIsolation=REPEATABLE_READ
     

    转载于:https://www.cnblogs.com/pangguoming/p/7028322.html

    展开全文
  • 之间的关系 一对多关系。例:客户与联系人 (1)一对一:一个分类里面有多个商品,一个商品只能属于一个分类。 (2)一对多:一个客户有很多联系人,一个联系人只能属于一个客户。 多对多关系。例:用户...

    表与表之间的关系

    1. 一对多关系。例:客户与联系人
      (1)一对一:一个分类里面有多个商品,一个商品只能属于一个分类。
      (2)一对多:一个客户有很多联系人,一个联系人只能属于一个客户。
    2. 多对多关系。例:用户和角色
      订单和商品的关系:一个订单里面有很多商品,一个商品属于多个订单。
      用户和角色的关系:总经理可以兼任司机,保安可以兼任秘书。

    一对多表的实现

    以客户与联系人为例,先创建对应的class文件。

    //客户的实体类
    package cn.zzuli.lhk;
    
    import java.util.HashSet;
    import java.util.Set;
    
    public class t_Customer {
    		private Integer cid;
    		private String name;
    		private String gender;
    		private String work;
    		private String phone;
    		private String Mobile;
    		private Set<t_LinkMan> setLinkMan = new HashSet<t_LinkMan>();
    		
    		public Set<t_LinkMan> getSetLinkMan() {
    			return setLinkMan;
    		}
    		public void setSetLinkMan(Set<t_LinkMan> setLinkMan) {
    			this.setLinkMan = setLinkMan;
    		}
    		public Integer getCid() {
    			return cid;
    		}
    		public void setCid(Integer cid) {
    			this.cid = cid;
    		}
    		public String getName() {
    			return name;
    		}
    		public void setName(String name) {
    			this.name = name;
    		}
    		public String getGender() {
    			return gender;
    		}
    		public void setGender(String gender) {
    			this.gender = gender;
    		}
    		public String getWork() {
    			return work;
    		}
    		public void setWork(String work) {
    			this.work = work;
    		}
    		public String getPhone() {
    			return phone;
    		}
    		public void setPhone(String phone) {
    			this.phone = phone;
    		}
    		public String getMobile() {
    			return Mobile;
    		}
    		public void setMobile(String mobile) {
    			Mobile = mobile;
    		}
    		
    }
    
    
    //联系人的实体类
    package cn.zzuli.lhk;
    
    public class t_LinkMan {
    	private Integer lid;
    	private String name;
    	private String gender;
    	private String phone;
    	private Integer clid;
    	private t_Customer customer;
    	
    	
    	public Integer getClid() {
    		return clid;
    	}
    	public void setClid(Integer clid) {
    		this.clid = clid;
    	}
    	public t_Customer getCustomer() {
    		return customer;
    	}
    	public void setCustomer(t_Customer customer) {
    		this.customer = customer;
    	}
    	public Integer getLid() {
    		return lid;
    	}
    	public void setLid(Integer lid) {
    		this.lid = lid;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getGender() {
    		return gender;
    	}
    	public void setGender(String gender) {
    		this.gender = gender;
    	}
    	public String getPhone() {
    		return phone;
    	}
    	public void setPhone(String phone) {
    		this.phone = phone;
    	}
    }
    
    

    配置xml属性文件。

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE hibernate-mapping PUBLIC 
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
        <!-- 客户的xml文件 -->
    <hibernate-mapping>
    	<class name = "cn.zzuli.lhk.t_Customer" table="t_Customer">
    		<id name = "cid" column = "cid">
    			<generator class="native"></generator>		
    		</id>
    		<property name="name" column = "name"></property>
    		<property name="gender" column = "gender"></property>
    		<property name="work" column = "work"></property>
    		<property name="phone" column = "phone"></property>
    		<property name="Mobile" column = "Mobile"></property>
    		<!-- name属性值为客户实体类中的联系人集合的名称 
    			双向维护外键,要做到前后外键名称一致
    		-->
    		<set name="setLinkMan">
    			<key column = "clid"></key>
    			<one-to-many class = "cn.zzuli.lhk.t_LinkMan"/>
    		</set>
    	</class>
    </hibernate-mapping>
       
    
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE hibernate-mapping PUBLIC 
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
        <!-- 联系人的xml文件 -->
    <hibernate-mapping>
    	<class name = "cn.zzuli.lhk.t_LinkMan" table = "t_LinkMan">
    		<id name = "lid" column = "lid">
    			<generator class="native"></generator>
    		</id>
    		<property name="name" column = "name"></property>
    		<property name="gender" column = "gender"></property>
    		<property name="phone" column = "phone"></property>
    		<!-- 双向维护外键 
    		name属性值为联系人实体类中Customer对象名称,这个很重要
    		-->
    		<many-to-one name = "customer" class = "cn.zzuli.lhk.t_Customer" column = "clid"></many-to-one>
    	</class>
    </hibernate-mapping>
       
    

    测试。

    package cn.zzuli.test;
    
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.Transaction;
    import org.junit.jupiter.api.Test;
    
    import cn.zzuli.lhk.t_Customer;
    import cn.zzuli.lhk.t_LinkMan;
    import hibernateUtils.hibernateUtils;
    
    public class hbtest2 {
        
    	@Test
    	public void testadd() {
    		
    		SessionFactory sessionfactory = null;
    		
    		//连接
    		Session session = null;
    		//开启事务
    		Transaction tx = null;
    		try {
    			sessionfactory = hibernateUtils.getSessionFactoryUtils();
    			
    			//连接
    			session = sessionfactory.openSession();
    			//开启事务
    			tx = session.beginTransaction();
    				
    				t_Customer customer = new t_Customer();
    				customer.setCid(1);
    				customer.setGender("男");
    				customer.setName("卓一");
    				customer.setMobile("15865946624");
    				customer.setPhone("03740081");
    				customer.setWork("政协委员");
    				
    				t_LinkMan linkman = new t_LinkMan();
    				linkman.setLid(1);
    				linkman.setName("王二");
    				linkman.setGender("男");
    				linkman.setPhone("15265658594");
    				//linkman.setClid(customer.getCid());
    				
    				customer.getSetLinkMan().add(linkman);
    				linkman.setCustomer(customer);
    				
    				session.save(customer);
    				session.save(linkman);
    				
    				tx.commit();
    		}catch(Exception e){
    			tx.rollback();
    			
    		}finally {
    				session.close();
    				sessionfactory.close();
    		}
    	}
    }
    
    

    得出结论。
    客户
    联系人

    个人感悟

    这个一对多建表我搞了很长时间,其中印象最深刻的就是配置文件这一过程,由于不细心对后期排查造成了很大困难,出现了各种各样的报错,也想过求援,但是代码是自己敲得,技术上不会了可以问一下子,排查bug的过程必须自己来做,这个感想算是纪念独立解决bug的一天。

    展开全文
  • 要把这些BEAN 的数据存放在数据库中的表结构,然而这些数据库中的表直接又有些特殊的关系,例如员工与部门直接有一对多的关系,学生与老师直接又多对多的关系,那么这些表的关系如何表示呢? 首先在建立数据库的时候...
  • 如何创建数据库表之间关联关系

    万次阅读 2015-10-24 16:04:22
    例如两张:Husbandwife,在数据库中设置彼此主键id相互关联(少用) 此时在两个实体类中不用添加任何对象属性 2.一对一单向外键关联 例如两张:Husbandwife ***在设计实体类时建立联系: 对象
  • 1、在你要添加新字段app models.py 文件添加需要新增字段(book新增authors字段并author建立多对多关系,author新增int类型age字段): class book(models.Model): name=models.CharField(max_...
  • 3、视图是基本表的抽象在逻辑意义上建立的新关系。 区别: 1、视图是已经编译好的sql语句。而表不是 2、表可以及时对它进行修改,但视图只能有创建的语句来修改 3、表是内容,视图是窗口 4、表只用物理空间而视图...
  • 我们都知道多对多的表需要建立关系表如下所示:表里数据怎么添加: 为什么存在关系表,因为学生课程之间产生了联系。 实际开发场景必然是:录入学生信息时候,要求选择学生课程,有人会疑问万一我不录课程...
  • 可视化表示将显示在工具的左侧,用户可以分析其当前数据库及其之间的关系。 lucidQL工具允许用户通过删除不再需要的任何关系来简化其架构。 如果最终产品不希望使用任何,只需将拖到垃圾图标,lucidQL将...
  • 但是在建立多对多关系的映射时,我们要借助一张中间表,并在中间表里添加外键,所以两张表的建表语句就是正常的建表语句,只需要添加每个表本身的字段即可,不需要添加额外属性。 随便举个例子吧,route表(线路)...
  • 如何理解表中记录实体对应关系?为什么说关系也是实体?在表中如何表示? 1.实体是客观存在并且可以相互区别事物,实体可以是具体事物,也可以是抽象事物。 2.不同事物是用不同特征决定,用来描述...
  • 在实际程序开发,我们通常在后台程序设计时候,用了大量抽象东西,接口,抽象类等等,也用了继承实现来快速扩展子类,这些都是为了让程序开发更加高效,模块化,易于分工协作等等;但是在数据库如何实现...
  • 程序运行后生成的数据库中,只会生成一个answer_usr,表示点赞(或收藏)的多对多关系,应该还有一个表示收藏(或点赞)的关系,我该怎么办</p>
  • 微软公司access是一个简单易用的数据库系统,对于初学者简单易懂,下面介绍如何创建表和关系: 1.新建空白桌面数据库 2.创建表 3.点击右上角视图 4.建立关系: 点击上图中的新建,选择要进行建立关系...
  • 绿道示例 该项目将演示如何使用 GreenDao 在这些对话中创建对话消息列表。 虽然可视化组件很简单,但GreenDao正在构建... 通过这种方式,您可以看到关系如何建立的以及数据是如何存储在数据库中的。 导出后使用
  • 关系数据库rdbms一个主要特征即多,外键关联或/并加以约束。关系数据库的优点,顾名思义,能够通过数据库本身操作来建立、保持并维护关系,由此在集中数据存储,可以提供很多便利。
  • 今天遇见了一个问题,在建立数据库表中发现,如果有两个不同用户,其中一个用户创建了一个,在代码永另一个用户去访问话,会就提示或视图不存在,那么就需要建立同义词了,同义词意思是就是,把一个...
  • 关系数据库

    2019-08-14 13:48:37
    关系数据结构:解决数据以什么形式来存储的问题,在基于关系模型的数据 库,数据是以二维表的形式存储的。 关系完整性约束:解决实体内部约束与实体之间约束的问题。 关系操作集合:解决如何关联管理存储...
  • 关系数据库范式详解

    2020-05-31 08:02:55
    关系数据库中,数据表是最基本的对象,表的好坏,直接关系到数据库的效率以及对数据库管理维护,因此,开始建立数据库之前,用户须先对数据库中的数据表进行仔细的分析设计。比如那些数据存放在一张表中、每个...
  • MySQL 数据库表 存储引擎查看与修改

    千次阅读 2018-04-17 15:50:52
    目录 存储引擎 简介 MySQL常用引擎 MyISAM InnoDB 查看数据库存储引擎 ...1、存储引擎通俗的说就是如何存储数据、如何为...2、因为在关系数据库中数据的存储是以表的形式存储的,所以存储引擎也可以称为表类型(即...
  • 之间如何建立关联映射

    千次阅读 2018-10-09 15:38:26
    那么 在数据库中怎么给数据添加外键呢 1.确定是给哪个添加外键关联 首先要明白你创建的的多个数据及其之间关联关系 举例User(一方)Customer(多方) 建立一对多联系(在“多”方实体中添加...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 664
精华内容 265
关键字:

数据库中表和表的关系如何建立