7.8--SSH学习之注解关联映射

最新推荐文章于 2022-03-17 15:03:00 发布
最新推荐文章于 2022-03-17 15:03:00 发布
阅读量217 收藏
点赞数 1
分类专栏： SSH学习之路 文章标签： 注解 hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/su1573/article/details/74906860
版权

之前记过配置文件方式的关联映射
可以参考：http://blog.csdn.net/su1573/article/details/74615709
现在记一下，用注解方式写的关联映射

单向多对一

只在多端配置；

多端:

@Entity(name="TABLE_STU")    //Entity标识本类为一个POJO类，name属性代表由这个类映射生成的表名//@TABLE(name="TABLE_STU"),还有其他属性，用table
public class Student {
    private Integer stuId;
    private String stuName;
    private String stuGender;
    private Integer stuAge;
    //单向多对一
    private Classes classes;

    @Id      //该属性为主键
    @GeneratedValue(strategy=GenerationType.AUTO)   //设置主键生成规则，AUTO为数据库默认生成主键

//  @GeneratedValue(strategy=GenerationType.IDENTITY)  //设置主键生成规则，IDENTITY使用数据库自增列来生成主键，适用于MySQL,SqlServer,DB2等

//  @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="stuSeq")   //SEQUENCE使用序列作为主键生成规则，适用于Oracle,DB2等
//  @SequenceGenerator(name="stuSeq",sequenceName="STU_SEQ",initialValue=1,allocationSize=1)    //产生一个名为STU_SEQ的新序列，主键引用这个新序列
                                                        //initialValue从1开始，allocationSize每次加一

//  @GeneratedValue(generator="currGen")    //引用名为currGen的主键为生成规则，
//  @GenericGenerator(name="currGen",strategy="uuid")  //strategy="uuid"为uuid方式产生主键，strategy="assigned"手动插入产生规则

    @Column(name="STU_ID")            //括号中可以指定类型，columnDefinition="timestap",length,（insertable=false,增加数据时，这个列不出现在新增语句中）
    public Integer getStuId() {        //该属性对应的列名
        return stuId;                   
    }
    public void setStuId(Integer stuId) {
        this.stuId = stuId;
    }

    @Column(name="STU_NAME",length=200)
    public String getStuName() {
        return stuName;
    }
    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    @Column(name="STU_GENDER" ,length=50)
    public String getStuGender() {
        return stuGender;
    }
    public void setStuGender(String stuGender) {
        this.stuGender = stuGender;
    }

    @Column(name="STU_AGE")
    public Integer getStuAge() {
        return stuAge;
    }
    public void setStuAge(Integer stuAge) {
        this.stuAge = stuAge;
    }
    //单向多对一
    @ManyToOne(targetEntity=Classes.class,fetch=FetchType.EAGER,cascade=CascadeType.ALL)
    @JoinColumn(name="CLASSES_ID")                //cascade={CascadeType.PERSIST,CascadeType.MERGE}不能级联增加，但是all 可以
    //多对一
    public Classes getClasses() {
        return classes;
    }
    public void setClasses(Classes classes) {
        this.classes = classes;
    }
}


一端：

@Entity(name="TABLE_CLASSES")
public class Classes {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    @Column(name="CLASSES_ID")
    private Integer classesId;

    @Column(name="CLASSES_NAME")
    private String classesName;
    //一对多
//  @OneToMany(targetEntity=Student.class,fetch=FetchType.EAGER,cascade=CascadeType.ALL)   //,mappedBy="classes"双向的时候写
//  @JoinColumn(name="CLASSES_ID")
//  private Set<Student> stuSet = new HashSet<Student>();
    //一对多
    public Integer getClassesId() {
        return classesId;
    }
    public void setClassesId(Integer classesId) {
        this.classesId = classesId;
    }
    public String getClassesName() {
        return classesName;
    }
    public void setClassesName(String classesName) {
        this.classesName = classesName;
    }
//  public Set<Student> getStuSet() {
//      return stuSet;
//  }
//  public void setStuSet(Set<Student> stuSet) {
//      this.stuSet = stuSet;
//  }
}



单向一对多

只在一段配置；

一端：

@Entity(name="TABLE_CLASSES")
public class Classes {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    @Column(name="CLASSES_ID")
    private Integer classesId;

    @Column(name="CLASSES_NAME")
    private String classesName;
    //一对多
    @OneToMany(targetEntity=Student.class,fetch=FetchType.EAGER,cascade=CascadeType.ALL)   //,mappedBy="classes"双向的时候写
    @JoinColumn(name="CLASSES_ID")
    private Set<Student> stuSet = new HashSet<Student>();
    //一对多
    public Integer getClassesId() {
        return classesId;
    }
    public void setClassesId(Integer classesId) {
        this.classesId = classesId;
    }
    public String getClassesName() {
        return classesName;
    }
    public void setClassesName(String classesName) {
        this.classesName = classesName;
    }
    public Set<Student> getStuSet() {
        return stuSet;
    }
    public void setStuSet(Set<Student> stuSet) {
        this.stuSet = stuSet;
    }
}


多端：

@Entity(name="TABLE_STU")    //Entity标识本类为一个POJO类，name属性代表由这个类映射生成的表名//@TABLE(name="TABLE_STU"),还有其他属性，用table
public class Student {
    private Integer stuId;
    private String stuName;
    private String stuGender;
    private Integer stuAge;
    //单向多对一
//  private Classes classes;

    @Id      //该属性为主键
    @GeneratedValue(strategy=GenerationType.AUTO)   //设置主键生成规则，AUTO为数据库默认生成主键

//  @GeneratedValue(strategy=GenerationType.IDENTITY)  //设置主键生成规则，IDENTITY使用数据库自增列来生成主键，适用于MySQL,SqlServer,DB2等

//  @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="stuSeq")   //SEQUENCE使用序列作为主键生成规则，适用于Oracle,DB2等
//  @SequenceGenerator(name="stuSeq",sequenceName="STU_SEQ",initialValue=1,allocationSize=1)    //产生一个名为STU_SEQ的新序列，主键引用这个新序列
                                                        //initialValue从1开始，allocationSize每次加一

//  @GeneratedValue(generator="currGen")    //引用名为currGen的主键为生成规则，
//  @GenericGenerator(name="currGen",strategy="uuid")  //strategy="uuid"为uuid方式产生主键，strategy="assigned"手动插入产生规则

    @Column(name="STU_ID")            //括号中可以指定类型，columnDefinition="timestap",length,（insertable=false,增加数据时，这个列不出现在新增语句中）
    public Integer getStuId() {        //该属性对应的列名
        return stuId;                   
    }
    public void setStuId(Integer stuId) {
        this.stuId = stuId;
    }

    @Column(name="STU_NAME",length=200)
    public String getStuName() {
        return stuName;
    }
    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    @Column(name="STU_GENDER" ,length=50)
    public String getStuGender() {
        return stuGender;
    }
    public void setStuGender(String stuGender) {
        this.stuGender = stuGender;
    }

    @Column(name="STU_AGE")
    public Integer getStuAge() {
        return stuAge;
    }
    public void setStuAge(Integer stuAge) {
        this.stuAge = stuAge;
    }
    //单向多对一
//  @ManyToOne(targetEntity=Classes.class,fetch=FetchType.EAGER,cascade=CascadeType.ALL)
//  @JoinColumn(name="CLASSES_ID")                //cascade={CascadeType.PERSIST,CascadeType.MERGE}不能级联增加，但是all 可以
    //多对一
//  public Classes getClasses() {
//      return classes;
//  }
//  public void setClasses(Classes classes) {
//      this.classes = classes;
//  }
}



双向多对一

在多端配置：
@ManyToOne()
@JoinColumn()
在一端配置：
@OneToMany(….,mappedBy=”classes”)
mappedBy属性如果设置则表明这一段放弃控制权

多端：

@Entity(name="TABLE_STU")    //Entity标识本类为一个POJO类，name属性代表由这个类映射生成的表名//@TABLE(name="TABLE_STU"),还有其他属性，用table
public class Student {
    private Integer stuId;
    private String stuName;
    private String stuGender;
    private Integer stuAge;
    //单向多对一
    private Classes classes;

    @Id      //该属性为主键
    @GeneratedValue(strategy=GenerationType.AUTO)   //设置主键生成规则，AUTO为数据库默认生成主键

//  @GeneratedValue(strategy=GenerationType.IDENTITY)  //设置主键生成规则，IDENTITY使用数据库自增列来生成主键，适用于MySQL,SqlServer,DB2等

//  @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="stuSeq")   //SEQUENCE使用序列作为主键生成规则，适用于Oracle,DB2等
//  @SequenceGenerator(name="stuSeq",sequenceName="STU_SEQ",initialValue=1,allocationSize=1)    //产生一个名为STU_SEQ的新序列，主键引用这个新序列
                                                        //initialValue从1开始，allocationSize每次加一

//  @GeneratedValue(generator="currGen")    //引用名为currGen的主键为生成规则，
//  @GenericGenerator(name="currGen",strategy="uuid")  //strategy="uuid"为uuid方式产生主键，strategy="assigned"手动插入产生规则

    @Column(name="STU_ID")            //括号中可以指定类型，columnDefinition="timestap",length,（insertable=false,增加数据时，这个列不出现在新增语句中）
    public Integer getStuId() {        //该属性对应的列名
        return stuId;                   
    }
    public void setStuId(Integer stuId) {
        this.stuId = stuId;
    }

    @Column(name="STU_NAME",length=200)
    public String getStuName() {
        return stuName;
    }
    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    @Column(name="STU_GENDER" ,length=50)
    public String getStuGender() {
        return stuGender;
    }
    public void setStuGender(String stuGender) {
        this.stuGender = stuGender;
    }

    @Column(name="STU_AGE")
    public Integer getStuAge() {
        return stuAge;
    }
    public void setStuAge(Integer stuAge) {
        this.stuAge = stuAge;
    }
    //单向多对一
    @ManyToOne(targetEntity=Classes.class,fetch=FetchType.EAGER,cascade=CascadeType.ALL)
    @JoinColumn(name="CLASSES_ID")                //cascade={CascadeType.PERSIST,CascadeType.MERGE}不能级联增加，但是all 可以
    //多对一
    public Classes getClasses() {
        return classes;
    }
    public void setClasses(Classes classes) {
        this.classes = classes;
    }
}


一端：

@Entity(name="TABLE_CLASSES")
public class Classes {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    @Column(name="CLASSES_ID")
    private Integer classesId;

    @Column(name="CLASSES_NAME")
    private String classesName;
    //一对多
    @OneToMany(targetEntity=Student.class,fetch=FetchType.EAGER,cascade=CascadeType.ALL)   //,mappedBy="classes"双向的时候写
//  @JoinColumn(name="CLASSES_ID")
    private Set<Student> stuSet = new HashSet<Student>();
    //一对多
    public Integer getClassesId() {
        return classesId;
    }
    public void setClassesId(Integer classesId) {
        this.classesId = classesId;
    }
    public String getClassesName() {
        return classesName;
    }
    public void setClassesName(String classesName) {
        this.classesName = classesName;
    }
    public Set<Student> getStuSet() {
        return stuSet;
    }
    public void setStuSet(Set<Student> stuSet) {
        this.stuSet = stuSet;
    }
}



多对多

两端都要写配置；

学生端：

@Entity(name="TABLE_TWOSTU")    //Entity标识本类为一个POJO类，name属性代表由这个类映射生成的表名//@TABLE(name="TABLE_STU"),还有其他属性，用table
public class TwoStudent {
    private Integer stuId;
    private String stuName;
    private String stuGender;
    private Integer stuAge;

    private Set<Teacher> stuTea = new HashSet<Teacher>();

    @Id      //该属性为主键
    @GeneratedValue(strategy=GenerationType.AUTO)   //设置主键生成规则，AUTO为数据库默认生成主键
    @Column(name="STU_ID")            //括号中可以指定类型，columnDefinition="timestap",length,（insertable=false,增加数据时，这个列不出现在新增语句中）
    public Integer getStuId() {        //该属性对应的列名
        return stuId;                   
    }
    public void setStuId(Integer stuId) {
        this.stuId = stuId;
    }

    @Column(name="STU_NAME",length=200)
    public String getStuName() {
        return stuName;
    }
    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    @Column(name="STU_GENDER" ,length=50)
    public String getStuGender() {
        return stuGender;
    }
    public void setStuGender(String stuGender) {
        this.stuGender = stuGender;
    }

    @Column(name="STU_AGE")
    public Integer getStuAge() {
        return stuAge;
    }
    public void setStuAge(Integer stuAge) {
        this.stuAge = stuAge;
    }

    @ManyToMany(targetEntity=Teacher.class,fetch=FetchType.EAGER,cascade=CascadeType.ALL)
    @JoinTable(name="TABLE_TEA_STU",joinColumns={@JoinColumn(name="STU_ID")},inverseJoinColumns={@JoinColumn(name="TEA_ID")})
    public Set<Teacher> getStuTea() {
        return stuTea;
    }
    public void setStuTea(Set<Teacher> stuTea) {
        this.stuTea = stuTea;
    }
}


教师端：

@Entity
public class Teacher {
    private Integer teaId;
    private String teaName;
    private String teaPwd;
    private Set<TwoStudent> stuSet = new HashSet<TwoStudent>();


    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    @Column(name="TEA_ID")
    public Integer getTeaId() {
        return teaId;
    }
    public void setTeaId(Integer teaId) {
        this.teaId = teaId;
    }

    @Column(name="TEA_NAME", length=200,nullable=false)
    public String getTeaName() {
        return teaName;
    }
    public void setTeaName(String teaName) {
        this.teaName = teaName;
    }
    @Column(name="TEA_PWD", length=200,nullable=false)
    public String getTeaPwd() {
        return teaPwd;
    }
    public void setTeaPwd(String teaPwd) {
        this.teaPwd = teaPwd;
    }

    @ManyToMany(targetEntity=TwoStudent.class,cascade=CascadeType.ALL,fetch=FetchType.EAGER)
    @JoinTable(name="TABLE_TEA_STU",joinColumns={@JoinColumn(name="TEA_ID")},inverseJoinColumns={@JoinColumn(name="STU_ID")})
    public Set<TwoStudent> getStuSet() {
        return stuSet;
    }
    public void setStuSet(Set<TwoStudent> stuSet) {
        this.stuSet = stuSet;
    }
}



一对一

两端也都要配置；

学生端：

@Entity(name="TABLE_THREESTU")
public class ThreeStudent {
    private Integer stuId;
    private String stuName;
    private String stuGender;
    private Integer stuAge;
    private StudentCard studentCard;

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    @Column(name="STU_ID")
    public Integer getStuId() {
        return stuId;
    }
    public void setStuId(Integer stuId) {
        this.stuId = stuId;
    }

    @Column(name="STU_NAME",length=200)
    public String getStuName() {
        return stuName;
    }
    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    @Column(name="STU_GENDER",length=50)
    public String getStuGender() {
        return stuGender;
    }
    public void setStuGender(String stuGender) {
        this.stuGender = stuGender;
    }

    @Column(name="STU_AGE")
    public Integer getStuAge() {
        return stuAge;
    }
    public void setStuAge(Integer stuAge) {
        this.stuAge = stuAge;
    }

    @OneToOne(targetEntity=StudentCard.class,cascade=CascadeType.ALL,fetch=FetchType.EAGER)
    @PrimaryKeyJoinColumn
    public StudentCard getStudentCard() {
        return studentCard;
    }
    public void setStudentCard(StudentCard studentCard) {
        this.studentCard = studentCard;
    }
}


学生卡端：

@Entity(name="TAB_CARD")
public class StudentCard {
    private Integer cardId;
    private String cardNum;
    private ThreeStudent threeStudent;

    @Id
    @GeneratedValue(generator="cardStuKey")
    @GenericGenerator(name="cardStuKey",strategy="foreign",parameters=@Parameter(name="property", value="threeStudent"))
    @Column(name="CARD_ID")
    public Integer getCardId() {
        return cardId;
    }
    public void setCardId(Integer cardId) {
        this.cardId = cardId;
    }

    @Column(name="CARD_NUM",length=200)
    public String getCardNum() {
        return cardNum;
    }
    public void setCardNum(String cardNum) {
        this.cardNum = cardNum;
    }

    @OneToOne(targetEntity=ThreeStudent.class,cascade=CascadeType.ALL,fetch=FetchType.EAGER,mappedBy="studentCard")
    @PrimaryKeyJoinColumn
    public ThreeStudent getThreeStudent() {
        return threeStudent;
    }
    public void setThreeStudent(ThreeStudent threeStudent) {
        this.threeStudent = threeStudent;
    }
}




配置文件中需要写：

         <mapping class="com.su.domain.Student"/>
        <mapping class="com.su.domain.Classes"/>
         <mapping class="com.su.domain.Teacher"/>
        <mapping class="com.su.domain.TwoStudent"/>
        <mapping class="com.su.domain.ThreeStudent"/>
        <mapping class="com.su.domain.StudentCard"/>



然后运读取配置文件的代码，即可在数据库自动建表：

public class HibernateTest {

    public static void main(String[] args) {

        // 默认读取hibernate.cfg.xml文件
        Configuration cfg = new Configuration().configure();

        // 生成并输出sql到文件（当前目录）和数据库 
        SchemaExport se = new SchemaExport(cfg);

        // 创建表结构，第一个true 表示在控制台打印sql语句，第二个true 表示导入sql语句到数据库
        se.create(true, true);      
    }

}



控制台显示成功信息如下：

INFO: HHH000046: Connection properties: {user=ssss, password=****}
七月 09, 2017 10:45:45 下午 org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000006: Autocommit mode: false
七月 09, 2017 10:45:45 下午 org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
INFO: HHH000115: Hibernate connection pool size: 1 (min=1)

    drop table TABLE_TEA_STU cascade constraints

    drop table TABLE_TWOSTU cascade constraints

    drop table Teacher cascade constraints

    drop sequence hibernate_sequence

    create table TABLE_TEA_STU (
        STU_ID number(10,0) not null,
        TEA_ID number(10,0) not null,
        primary key (TEA_ID, STU_ID)
    )

    create table TABLE_TWOSTU (
        STU_ID number(10,0) not null,
        STU_AGE number(10,0),
        STU_GENDER varchar2(50 char),
        STU_NAME varchar2(200 char),
        primary key (STU_ID)
    )

    create table Teacher (
        TEA_ID number(10,0) not null,
        TEA_NAME varchar2(200 char) not null,
        TEA_PWD varchar2(200 char) not null,
        primary key (TEA_ID)
    )

    alter table TABLE_TEA_STU 
        add constraint FK_dnnscrifuvtxpg4t3c9oo1aaq 
        foreign key (TEA_ID) 
        references Teacher

    alter table TABLE_TEA_STU 
        add constraint FK_feeoifq2kgnybn2rvw4muoq8p 
        foreign key (STU_ID) 
        references TABLE_TWOSTU

    create sequence hibernate_sequence
七月 09, 2017 10:45:46 下午 org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl stop
INFO: HHH000030: Cleaning up connection pool [jdbc:oracle:thin:@localhost:1521:xe]
七月 09, 2017 10:45:46 下午 org.hibernate.tool.hbm2ddl.SchemaExport execute
INFO: HHH000230: Schema export complete

完结！！！

Author:su1573

ssy03092919
关注
专栏目录
Docker学习总结（12）——非常详细的 Docker 学习笔记
科技D人生
08-03 6809
一、Docker 简介 Docker 两个主要部件： Docker: 开源的容器虚拟化平台Docker Hub: 用于分享、管理 Docker 容器的 Docker SaaS 平台 -- Docker Hub Docker 使用客户端-服务器 (C/S) 架构模式。Docker 客户端会与 Docker 守护进程进行通信。Docker 守护进程会处理复杂繁重的任务，例如建立、运行、发
mybatis-spring-springMVC-springBoot总结
m0_55668402的博客
04-23 855
mybatis-spring-springMVC-springBoot特点区别 介绍 第一节 mybatis 1、mybatis简介 MyBatis原本是Apache软件基金会的一个开源项目叫iBatis，2010年这个项目由Apache迁移到了google code上来管理并改名为MyBatis，2013年又迁移到了Github。 MyBatis是一个非常优秀的持久层框架(DAO层框架)，它是对JDBC的封装，使得开发者只需要关注SQL语句(业务)本身即可，无需开发者处理加载驱动、获取连接、创建State
SSH框架学习笔记(六)----hibernate关联映射注解
dingduowang4794的博客
04-20 113
@Discriminator 作用:当父类与子类的数据都记录在统一在表的时候,通过该注解区分不同类的数据 使用:根父类需要用@DiscriminatorColumn修饰,name属性指定表中用来区分的字段,discriminatorType属性指定区分字段的类型;@DiscriminatorValue用于修饰所有子类和父类,value属性指定不同实体在辨别者列上的值. @M...
SSH关联映射注解
zhaohan___的博客
09-14 294
关联映射 多对一many-to-one 建立User和Note的单表映射 在Note类中加user属性，删除原有的userId属性 在user属性前追加下面标记//追加关联属性 Note(n) User(1) @ManyToOne(fetch=FetchType.LAZY) @JoinColumn(name=”USER_ID”) private User user;public U
SSH集成时使用注解代替实体映射hbm.xml文件的配置过程
chouranguo4320的博客
07-02 240
在最原始的ssh开发中Hibernate需要配置hbm.xml实体映射文件，遇到表较多及表关系复杂时极其麻烦； 现在一般都会通过JAR包中的配置好的注解代替原来的这种配置： 在beans.xml配置文件（applicationContext.xml）中将 <property nam...
映射和反射的概念及应用方法
Fredrik的博客
07-10 1346
映射和反射的概念及应用方法
Spring + Hibernate 使用注解方式和配置文件方式映射实体类时spring_hibernate.xml 配置
阿飞
12-05 2363
Spring + Hibernate 使用注解方式和配置文件方式映射实体类时spring_hibernate.xml 配置
Java学习路线，Java SE，EE，ME的区别，SSM框架基本概念
小哈里的博客
02-26 1802
1、尚硅谷 视频课程：https://www.bilibili.com/read/cv5216534 初学者可按照尚硅谷公开的JAVA视频最快学习路线： JavaSE --> MySQL–> JDBC --> JavaWeb --> Spring5 --> SpringMVC --> MyBatis --> Maven --> Ssm框架整合案例 --> Git/GitHub --> Redis6 --> MySQL高级优化 --> M
Java学习笔记-个人整理的
12-19
{7.8}Buffer}{112}{section.7.8} {7.9}字符流}{112}{section.7.9} {7.10}缓冲字符输入输出流}{113}{section.7.10} {7.11}文件常用操作}{114}{section.7.11} {7.12}对象序列化}{117}{section.7.12} {8}多线程}{...
Java 全栈知识体系（ PDF 可下载）
m0_67698950的博客
03-17 5504
40000 +字长文总结，民工哥已将此文整理成PDF文档了，需要的见文后下载获取方式。 全栈知识体系总览 Java入门与进阶 面向对象与Java基础 Java 基础 - 面向对象 Java 基础 - 知识点 Java 基础 - 图谱 & Q/A 基础知识点复习完了以后，我们需要深入的理解Java中的一些基础机制： Java 基础 - 泛型机制详解 Java泛型这个特性是从JDK 1.5才开始加入的，因此为了兼容之前的版本
Spring总结
Biubiubiu!
01-01 2777
文章目录一、Spring概述和IOC理论1、Spring1.1、简介1.2、优点1.3、组成1.4、拓展2、IOC理论推导2.1、分析实现2.2、IOC本质二、Spring：第一个程序、对象创建方式、配置说明3、第一个程序Hello3.1、导入Jar包3.2、编写代码3.3、思考4、IOC创建对象方式4.1、通过无参构造方法来创建4.2、通过有参构造方法来创建5、Spring配置5.1、别名5.2...
SSH 三大框架整合
吴瑶的博客
11-16 240
1. Spring整合Struts2框架，存在2种方式（Action对象由哪个框架创建的） * 导入开发的jar包 * struts2-spring-plugin-2.3.24.jar * Action对象可以由Struts2框架创建，默认的方式 * 因为导入struts2-spring-plugin-2.3.24.jar包，提供类struts-plugin.xml配置文件， 该文件
SSH——hibernate 利用注解实现实体关联映射详解
Think In JAVA—Max
11-02 7200
一、JPA: JPA全称Java Persistence API.JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中实现数据持久化。同时，它还是JCP 组织发布的 Java EE 标准之一，因此任何声称符合 JPA 标准的框架都遵循同样的架构。而Hibernate 从3.2开始，就开始兼容JPA，也就是说，除了通过配置xml实现实体关
SSH所有注解 加上注解整合详细步骤
towerLJYT的博客
05-12 6822
SSH注解(不用死记硬背,有个印象就好)----------Spring--------------创建对象---@Component(美[kəm'ponənt]啃破门特)作用：相当于bean.xml文件中，bean标签使用&lt;bean id=”” class=”” /&gt;属性：value：给bean取一个名称，相当于bean标签的id属性。细节：如果不指定，默认使用类的名称（首字母小写...
ssm项目---人事管理系统：员工与部门、职位实现一对一
HY0101的博客
08-08 4434
概要说明：在这个员工实现分页功能上耗费了相当大的精力，首先需要晓得一对一是怎么配置的，然后就是sql语句是怎么写的，这两个缺一不可。 Page类参考：http://blog.csdn.net/su1573/article/details/76889339 1.创建Employee.java和Employee.xml映射文件 Employee.java public class Employee {
ssm项目---人事管理系统：分页示例
HY0101的博客
08-08 3291
概要说明：最近做了一个ssm项目—人事管理系统 现在分享一下对User的分页查询 效果图如下： 代码示例 1. 首先建立一个Page类，应包含每页显示的记录数，总页数，当前页，总记录数，和一个list对象，起始位置 package com.su.util;import java.util.List;public class Page { public stati
7.27--SSH学习之SpringMVC，Ajax请求、拦截器、文件上传和MyBatis访问数据库基本操作
HY0101的博客
07-27 2066
第一点：ajax请求在一个表单中由jquery发起一个ajax请求，然后访问控制器，返回json结果，最后把结果显示在原表单中。 1. 下面是一个用户注册页面，当输入用户名时就立即发起ajax请求，来判断这个用户名是否可用 注册表单如下：<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <% String pa
7.29--SSH学习之使用Maven导jar包
HY0101的博客
07-29 866
一、首先需要下载maven框架 1. 官网下载 2. 参考（免费下载）：http://download.csdn.net/detail/su1573/9914873 二、下载完后解压，最好解压在一个新建文件夹中，例如D:\Maven 然后在与“apache-maven-3.3.9”文件夹同级下建一个名为“repository”的文件夹 三、之后打开apache-maven-3.3.9-
从jsp页面framset框架中跳出到一个全新的jsp页面
HY0101的博客
08-08 850
在新的jsp页面head标签中间加<script type="text/javascript"> if (window != top){ top.location.href = location.href; } </script>就可以了
pcre-devel-7.8-6-el6.x86_64.rpm下载
最新发布
10-11
pcre-devel-7.8-6-el6.x86_64.rpm 是一个用于CentOS或RHEL 6.x (64位)系统的RPM文件，它是Perl Compatible Regular Expressions (PCRE) 库的开发包。PCRE是一个功能强大的正则表达式库，用于在文本匹配和模式搜索中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ssy03092919

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值