Struts-2.5-动态方法通配符使用 struts.xml 配置以下就是struts 2.5 版本的通配符配置，和原来的2.3版本有点区别（第一次运行服务的时候尽量连上网络）第一种所有文件都采用通用命名规范{1}、{2}、{3}分别指第一个*（方法名）、第二个*（action类名）、第三个*（跳转页面也是方法返回的结果码）allowed-methods 可以放置多个方法名第二种在package加上<global-allowed-methods>regex:.*</global-allowed-methods> jsp Action   

Struts2框架原理 Struts2官网https://struts.apache.org/Struts2是一个开源的轻量级的，应用于web层（View）的框架。 Struts2框架的MVC分别对应：M：JavaBean + ModelDrivenV：JSP + OGNLC：ActionStruts2框架的控制器将“获取请求”和“分发转向”代码抽取出来写在配置文件中，这样一样，控制器（action类）就能专注于业务逻辑的处理了。 Struts2框架内部运行原理图 Struts2五个核心部件 Actions（动作） Interceptors（拦截器） Value Stack / OGNL（值栈 / OGNL） Results / Result types（返回结果） View technologies（视图）  Action获取web对象使用ActionContext类（解耦方式——即struts2测试时不需要启动服务器，提高开发效率）Web应用中通常需要访问的Servlet API就是HttpServletRequest、HttpSession和ServletContext，这三个接口分别代表JSP内置对象中的request、session和application。 Struts2提供了一个ActionContext类（com.opensymphony.xwork.ActionContext），它是Action执行时的上下文，上下文可以看作是一个容器（其实我们这里的容器就是一个Map而已），它存放的是Action在执行时需要用到的对象。可以通过下面方法访问Servlet API： Objectget(key) 类似于HttpServletRequest的getAttribute(String) MapgetApplication() 返回一个Map对象 static ActionContextgetContext() 返回静态的ActionContext实例，相当于HttpServletRequest对象 HttpParameters getParameters() 获取所有的请求参数 Map getSession() 返回一个Map对象 void setApplication(Map) 向application传入一个Map对象 voidsetSession(Map) 向session传入一个Map对象 voidput(key, value) 添加对象  如何获得地址栏参数、表单参数：（struts版本不一样使用也不一样） ActionContext context = ActionContext.getContext(); // 得到HttpServletRequest对象的attribute（解耦）Map<String, Parameter>paramsMap =context.getParameters();Stringtype =paramsMap.get("type").toString(); // 得到request对象HttpServletRequestrequest = (HttpServletRequest)context.get(StrutsStatics.HTTP_REQUEST);Stringtype2 =request.getParameter("type"); 案例1：使用ActionContext操作作用域 ActionContext ac = ActionContext.getContext();Integer count = (Integer) ac.getApplication().get(“count”);// 通过ActionContext设置application范围的属性ac.getApplication().put(“count”, 100);// 通过ActionContext设置session范围的属性ac.getSession().put(“max”, 1000);// 通过ActionContext设置request范围的属性ac.put(“min”, 10);  前端页面： 统计总人数：${applicationScope.count}最大人数：${sessionScope.max}最小人数：${requestScope.min}  案例2：使用ActionContext获得JSP表单中的数据（1）创建表单，提交表单到action里面 <form action=”/register” method=”post”>用户名：<input type=”text” name=”uname” />手机号：<input type=”text” name=”moblie” />性别：<input type=”radio” name=”sex” value=”1” / >男 <input type=”radio” name=”sex” value=”0” />女    <input type=”submit” value=”提交” /></form>  （2）在action使用ActionContext获取表单数据： ActionContext ac = ActionContext.getContext();// map的key就是表单项的各nameMap<String, Object> map = ac.getParameters(); //查看Map中的数据Set<String> keys = map.keyset();for(String key : keys){     Object[] obj = (Object[])map.get(key);System.out.println(Arrays.toString(obj));} 使用ServletActionContext类（耦合方式） HttpServletRequest request = ServletActionContext.getRequest();request.setAttribute("request", "1"); HttpSession session = request.getSession();session.setAttribute("session", "2"); ServletContext application = request.getSession().getServletContext();application.setAttribute("application", "3"); 不建议直接访问servlet的API，不利于项目移植。使用ServletXxxAware接口注入（耦合方式）使用ServletContextAware、ServletRequestAware、ServletResponseAware三个接口可直接获得Servlet API。Step1：类实现ServletResponseAware接口（或其它两个接口）。Step2：重写相应的方法： // 自定义类实现：ServletXXXAware接口，实现方法public class Test implements ServletRequestAware,ServletSessionAware……{ private HttpServletRequest request;     @Override    public void setServletRequest(HttpServletRequest request){         this.request = request;    }     public String execute() throws Exception{         return NONE;    }}  Action表单数据封装（属性驱动、模型驱动）案例：表单数据提交对应数据在前台与后台中的交互，Struts2框架替我们做了很大部分的数据封装工作。既可以封装单个对象，也可以封装集合。 实现Action有两大方式：属性驱动、模型驱动。（1）属性驱动使用属性作为贯穿MVC流程的信息携带者，依附于Action实例，Action实例封装请求参数和处理结果。属性驱动有三种：普通POJO类、实现Action接口、继承ActionSupport（推荐）。普通POJO类实现一个登录Action： public class LoginAction {     //私有属性    private String username;    private String password;//struts2的拦截器机制，getter/setter方法负责解析用户请求参数，并且将请求参数值赋给action对应的属性（也就是说将form表单的数据赋值给Action类中的属性，属性名与表单项控件名一致）//此处省略set和get方法     public String execute() throws Exception {         if("test".equals(getUsername()) && "123".equals(getPassword())){             return "success";        }else{             return "error";        }    }} 实现Action接口为了让用户开发的Action类更加规范，Struts2提供Action接口，定义了Action处理类应该实现的规范。 实现步骤： Action类实现Action接口，重写execute()方法，返回时使用Action接口中的常量； 在Action中声明成员变量，成员变量名与表单项name属性一致； 封装。  案例： //1. 实现Action接口public class LoginAction implements Action {     //2. 私有属性    private String username;    private String password;//3. 此处省略set和get方法 //返回使用Action接口中的常量    public String execute() throws Exception {         if("test".equals(getUsername()) && "123".equals(getPassword())){             return SUCCESS;        }else{             return ERROR;        }    }}  Action接口代码： public interface Action{     // 定义Action接口里包含的一些结果字符串public static final String ERROR=”error”;public static final String INPUT=”input”;public static final String LOGIN=”login”;public static final String NONE=”none”;public static final String SUCCESS=”success”;// 定义处理用户请求的execute方法public String execute() throws Exception;}  继承ActionSupport类（推荐）ActionSupport类是Action接口的实现类。该类提供了许多默认的方法，这些默认方法包括获得国际化信息的方法、数据校验的方法、默认的处理用户请求的方法等。如果配置Action没的指定的Action类，系统自动使用ActionSupport类作为Action处理类。 实现步骤： 继承ActionSupport，重写execute()方法。不继承也可以，直接写execute()方法； 在Action中声明成员变量，成员变量名与表单项name属性一致； 封装。  案例： //1. 继承ActionSupport类public class LoginAction extends ActionSupport {     //2. 声明成员变量（与表单项name一致，这里最好是私有化一个实体类对象，参见后面的）    private String username;    private String password;//3. 封装，省略getter/setter方法//struts2的拦截器机制，getter/setter方法负责解析用户请求参数，并且将请求参数值赋给action对应的属性     public String execute() throws Exception {         if("test".equals(getUsername()) && "123".equals(getPassword())){             return SUCCESS;        }else{             return ERROR;        }    }} （2）模型驱动就是使用单独的JavaBean实例来贯穿整个MVC流程，JavaBean实例封装请求参数和处理结果。模型驱动有一种：ModelDriven。模型驱动封装：ModelDriven（推荐）模型驱动：就是使用单独的JavaBean实例来贯穿整个MVC流程，JavaBean实例封装请求参数和处理结果。 实现步骤：（1）Action类实现ModelDriven接口；（2）实现接口的getModel()方法，并把创建对象返回；（3）在Action中创建实体类对象；（4）execute()一样法中使用实体类对象名即可。 案例： //1. 实现ModelDriven接口public class LoginAction3implements ModelDriven<User> {     //定义用于封装请求参数和处理结果的Modelprivate Useruser= new User();    //2. 实现接口的getModel()方法，并把创建对象返回    @Override    public User getModel() {         return user;    }    //4. 在execute()中使用对象    public String execute() throws Exception {         if("test".equals(user.getUsername()) && "123".equals(user.getPassword())){             return SUCCESS;        }else{             return ERROR;        }    }}  User类：属性名要与表单控件名字相同，否则报错。 //3. 创建实体类并封装public class User implements Serializable{     private static final long serialVersionUID = 1L;    // 私有的请求参数    private String username;    private String password;// 省略set和get方法     public User() {     }    public User(String username, String password) {         super();        this.username = username;        this.password = password;    }    @Override    public String toString() {         return "User [username=" + username + ", password=" + password + "]";    }}  （在这里简单说一下本人在使用struts2开发时，在对Action类使用时继承的是pojo（entity）类，在实体类中可以实现接口ModelDriven，重写getModel()方法返回this 或者 不实现接口自己写 一个方法返回this。因为之前有提到 如果配置Action没的指定的Action类，系统自动使用ActionSupport类作为Action处理类。所以当Action类继承pojo（entity）类时不管是属性驱动获值还是模型驱动获值都可以。在Action中就不必封装属性或对象）  

-bash: /usr/local/maven/apache-maven-3.5.4/bin/mvn: Permission denied -bash: /usr/local/maven/apache-maven-3.5.4/bin/mvn: Permission denied这种错误是权限问题，只需设置好权限就OK执行：chmod a+x /usr/local/maven/apache-maven-3.5.4/bin/mvn

发布web项目到服务器页面无数据 服务器是 Centos系统期间自己出现的问题：发布项目通过域名能访问首页，但却没有绑定数据。配置web.xml的 <welcome-file-list>时可以配置另外一个页面，从另外一个页面跳转至首页（页面加<meta http-equiv='refresh'   content='0;url=index.jsp'> refresh[刷新-这里指定动作] ，content="0;URL="，这里0表示没有延时，直接跳转到后面的URL；把0改成1，则延时1秒后跳转。）在其他页面没有获得数据，但是在eclipse运行项目可以获得数据，把获数据的sql语句在服务器的mysql执行看看能不能查到数据，我的问题是 select * from T_a;本地可以查但是服务器报错，发现是表名的原因select * from t_a;改成这样就可以查出数据，原因是服务器的mysql区分大小写，本地的大小写都无所谓。点击→这里有写到怎么解决大小写问题

接口（interface）与类、抽象类 什么是接口？      接口可以看做特殊的抽象类，即只包含抽象方法和常量的变量。      用interface修饰 接口的定义    [修饰符] interface 接口名 extends 父接口1, 父接口2……{         零到多个常量定义……        零到多个抽象方法定义……        零到多个内部类、接口、枚举定义……        零到多个默认方法或类方法定义……    }例如：public interface InterfaceName{    ......}注意：   1.修饰符只能是public或者省略，如果省略则只能在同包下访问接口   2.接口的命名和类命名规则一样   3.接口中的方法全都是抽象方法，没有方法体（默认abstract修饰）   4.类可以实现多个接口   5.一个接口可以继承多个接口，接口直接是多继承关系   6.接口中的成员变量全都是常量，没有构造方法   7.接口只能继承接口，接口与其具体的实现类之间存在多态性 类与接口的继承一个类只可以继承一个父类，可实现多个接口，一个接口可以继承多个父接口。接口的使用接口不能用于创建实例，但可以用于声明引用类型变量。也可用于进行强制类型转换实现类必须实现接口的所有方法 抽象类 （用abstract修饰的类）    抽象类只能单继承，而接口（interface）可以多实现    抽象类继承用extends，而接口用implements    抽象类可以有构造，接口不能    抽象类可以有一般的属性，接口中的属性只能是静态常量    抽象类中可以有抽象方法，也可以有一般的方法，而接口中只能有抽象方法    抽象类中抽象方法可以被除private以外的修饰符修饰，但是接口中只能是public  接口与抽象类的区别共同点：    接口和抽象类都不能被实例化，它们都位于继承的顶端，用于被其他类实现和继承；    接口和抽象类都可以包含抽象方法，实现接口或继承提象类的普通子类都必须实现这些抽象方法。 不同点：    1.接口里只能包含抽象方法，静态方法和默认方法，不能为普通方法提供方法实现；抽象类则完全可以包含普通方法。    2.接口里只能定义静态常量，不能定义普通成员变量；抽象类里则既可以定义普通成员变量，也可以定义静态常量。    3.接口里不包含构造方法；抽象类里可以包含构造方法，抽象类里的构造方法并不是用于创建对象，而是让其子类调用这些构        造方法来完成属于抽象类的初始化操作。    4.接口里不能包含初始化块；但抽象类则完全可以包含初始化块。    5.一个类最多只能有一个直接父类，包括抽象类；但一个类可以直接实现多个接口，通过实现多个接口可以弥补java单继承的不足。    类的继承与接口的实现    接口与接口之间用    extends    接口与类之间用    implements    类与类之间用    extends         

Hibernate（一）：一对一（one to one）配置及基本CURD 以下是基于一个人对应一个号码的映射配置及级联CURD例子 hibernate.cfg.xml<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate</property> <property name="hibernate.connection.password">root</property> <property name="hibernate.connection.username">root</property> <property name="show_sql">true</property> <property name="format_sql">true</property> <mapping resource="club/lygangdai/entity/Person.hbm.xml"/> <mapping resource="club/lygangdai/entity/Card.hbm.xml"/> </session-factory> </hibernate-configuration>  Person.javapackage club.lygangdai.entity; /** * @ClassName: Province * @Description: TODO(人 类) * @author Uncle * @date 2018年8月7日 上午9:50:48 * */ public class Person { private int pid; //id private String pname; //人名 private Card c; //卡对象 /** * @Description: TODO(这里用一句话描述这个类的作用) * @param pid * @param pname */ public Person(int pid, String pname) { super(); this.pid = pid; this.pname = pname; } /** * @Description: TODO(这里用一句话描述这个类的作用) */ public Person() { super(); } /** * @return pid */ public int getPid() { return pid; } /** * @param pid 要设置的 pid */ public void setPid(int pid) { this.pid = pid; } /** * @return pname */ public String getPname() { return pname; } /** * @param pname 要设置的 pname */ public void setPname(String pname) { this.pname = pname; } /** * @return c */ public Card getC() { return c; } /** * @param c 要设置的 c */ public void setC(Card c) { this.c = c; } /* (非 Javadoc) * @Title: toString * @Description: TODO(这里用一句话描述这个方法的作用) * @return * @see java.lang.Object#toString() */ @Override public String toString() { return "Province [pid=" + pid + ", pname=" + pname + "]"; } }  Person.hbm.xml<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <!-- Generated 2018??8??7?? ????10:44:13 by Hibernate Tools 3.5.0.Final --> <hibernate-mapping> <!--映射实体类对象，生成默认为person的数据库表--> <class name="club.lygangdai.entity.Person" table="person"> <id name="pid" type="int"> <!-- 指定类的id --> <column name="pid" /> <!-- 对应表的列 --> <generator class="native" /><!-- 自增 --> </id> <property name="pname" type="java.lang.String"> <column name="pname" /> </property> <one-to-one name="c" class="club.lygangdai.entity.Card" cascade="all-delete-orphan"></one-to-one> <!-- 映射 一对一关系 --> </class> </hibernate-mapping> 在 cascade（级联）的配置 Card.javapackage club.lygangdai.entity; /** * @ClassName: city * @Description: TODO(卡类) * @author Uncle * @date 2018年8月7日 上午9:40:17 * */ public class Card { private int cid; //id private String cname; //卡号 private Person p; //person对象 /** * @return p */ public Person getP() { return p; } /** * @param p 要设置的 p */ public void setP(Person p) { this.p = p; } /** * @Description: TODO(这里用一句话描述这个类的作用) */ public Card() { super(); } /** * @return cid */ public int getCid() { return cid; } /** * @param cid 要设置的 cid */ public void setCid(int cid) { this.cid = cid; } /** * @return cname */ public String getCname() { return cname; } /** * @param cname 要设置的 cname */ public void setCname(String cname) { this.cname = cname; } /* (非 Javadoc) * @Title: toString * @Description: TODO(这里用一句话描述这个方法的作用) * @return * @see java.lang.Object#toString() */ @Override public String toString() { return "Card [cid=" + cid + ", cname=" + cname + "]"; } }   Card.hbm.xml<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <!-- Generated 2018??8??7?? ????10:44:13 by Hibernate Tools 3.5.0.Final --> <hibernate-mapping> <!--映射实体类对象，生成默认为card的数据库表--> <class name="club.lygangdai.entity.Card" table="card"> <id name="cid" type="int"> <!-- 对应实体类的id --> <column name="cid" /> <!-- 对应表的列 --> <!-- 采用foreign生成策略，forgeign会取得另外一个关联对象的标识 --> <generator class="foreign"><!-- 外键 --> <param name="property">p</param><!-- 指定person表，对应的id --> </generator> </id> <property name="cname" type="java.lang.String"> <column name="cname" /> </property> <!-- 映射 一对一关系 --> <one-to-one name="p" class="club.lygangdai.entity.Person"></one-to-one> </class> </hibernate-mapping>  HibernateTest.java package test; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.Transaction; import org.hibernate.cfg.Configuration; import org.junit.Test; import club.lygangdai.entity.Card; import club.lygangdai.entity.Person; /** * @ClassName: HibernateTest * @Description: TODO(这里用一句话描述这个类的作用) * @author Uncle * @date 2018年8月7日 上午8:58:50 * */ public class HibernateTest { @Test public void hibernateTest() { //读取配置文件 Configuration configuration = new Configuration().configure(); //创建工厂 SessionFactory sessionFactory = configuration.buildSessionFactory(); //session Session session = sessionFactory.openSession(); //事务 Transaction transaction = session.beginTransaction(); //级联关系 //增加 person表和card表 // Person p = new Person(); // p.setPname("张三"); // Card c = new Card(); // c.setCname("1123456"); //互设 // p.setC(c); // c.setP(p); //保存 // session.save(p); //修改 //得到person 修改card的cname // Person p = session.get(Person.class, 2); // p.getC().setCname("卡号"); // session.update(p); //得到card 修改person的pname // Card c = session.get(Card.class, 2); // c.getP().setPname("xx"); // session.save(c); //删除 //级联删除 先查出主表数据，再删除主表数据，子表数据同步删除（查子表数据级联删除不生效） // Person p = session.get(Person.class, 8); // session.delete(p); //单独删一张表 直接新建对象，给id赋值，删除对应id的数据 // Card c = new Card(); // c.setCid(7); // session.delete(c); //提交 transaction.commit(); //关闭session及sessionFactory session.close(); sessionFactory.close(); } }  

I/O流 IO流的概念    通过数据流、序列化和文件系统提供系统输入和输出。 IO：I =>  Input   输入---将数据源读到内存中；                 相当于读取硬盘上的文件        O =>  Output  输出---将内存数据写（保存）到介质(硬盘)里；                 相当于保存文件。IO流体系IO流分：字节流和字符流        字节流分：输入流和输出流            inputStream   outputstream        字符流分：输入流(读流)和输出流（写流）            reader        writerFile类    java.io.File类，包含了对文件和文件夹的操作方法，可通过File类对文件或文件夹进行操作(新建、删除、重命名等)。    File类不能访问文件中的内容，如需要访问文件内容则需要输入/输出流。构造方法   a. File(String pathname)   //创一个新的File实例（即可以是文件也可以是文件夹）   例： File fi = new File("e:\\text\\a.txt");        File fi = new File("e:\\text\\t1\\");　　b. File(File parent, String child)    例：File fi = new File("e:\\text","a.txt");　　c. File(String parent, String child)　　d. File(URI uri)　　parent指定路径（父目录），可以是File类对象也可以是字符串，child中也可以加入路径层级，但要注意，所用的路径必须存在，不存在的路径不会新建。 常用方法：   boolean    isDirectory();        //判断是否是目录   boolean    isFile();        //判断是否是文件   File     getAbsolutePath();     //获得文件的绝对路径   boolean    isHidden();        //判断是否是隐藏文件   boolean    exists();        //判断所关联的文件或文件夹是否存在   boolean    createNewFile();     //创建一个新的文件(仅当对象文件不存在时)   boolean    mkdir();         //创建一个文件夹   //要用mkdir()创建目录，必须上一级目录存在，即最底层目录前面的目录全都存在   boolean    mkdirs();         //创建一个文件夹   //要想把File对象包含的目录一次性全都创建好，可以使用mkdirs()方法。   boolean    renameTo(File dest);    //重命名文件，为文件或文件夹改名   例：File fi1 = new File("e:\\a.txt");       File fi2 = new File("e:\\b.txt");       fi1.renameTo(fi2);**********************************************关于斜杠和反斜杠，只能如下生硬地先记住吧：\\：右手用两个，比如new File("D:\\abc\\" + "Test.txt"); /：左手用一个。比如new File("D:/abc/" + "Test.txt");**********************************************   boolean    delete();          //删除指定的文件或文件夹   void        deleteOnExit();      //在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。   boolean    equals(Object obj);    //比较的文件名字相同为true，不同为false   文件管理：   String    getName();        //获得文件名或目录名   String    getParent();         //获得文件的上一级父目录的名字   File        getParentFile();      //获得文件的上一级父目录的对象   问：getParent()与getParentFile()的区别？    getParent()返回此抽象路径名父目录的路径名字符串；    如果此路径名没有指定父目录，则返回 null。      getParentFile()返回此抽象路径名父目录的抽象路径名；    如果此路径名没有指定父目录，则返回 null。   long     lastModified();        //获得文件的最后修改时间（毫秒，当前时间与格林时间（1970 年 1 月 1 日，00:00:00 GMT）之间的毫秒数）   long     length();        //获得文件大小（长度），以字节为单位   String[]    list();            //获得指定文件夹下的所有文件的名字   File[]    listFiles();        //获得文件夹下的所有文件的对象   //注：即是文件对象，那文件对象还有其他的属性，比如：    文件名：getName();    文件路径：getPath();    文件后缀名：str.substring(str.lastIndexOf(".")+1);    文件大小：length();    最后修改时间：lastModified();   static File  listRoots();   //获得当前系统的盘符     问：获得系统所有的盘符怎么操作？       File[] f = File.listRoots();       for(File ss:f){        System.out.println(ss.getPath());       }-----------------------------------------------------------将毫秒数转成日期：    SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");      //该类用来对日期字符串进行解析和格式化输出    System.out.println(sdf.format(毫秒数));  列出一个文件夹下所有子文件夹以及子文件。    (1)指定文件夹路径；    (2)判断是否是文件，是文件就打印文件路径（到最底层了）；相反如果是目录，则继续；    (3)获取文件夹下所有文件对象；    (4)遍历对象数组，执行递归。   递归写成方法： File fs=new File("e:\\");    public static void prints(File f) {         if(f.isFile()){ //判断是否是文件            System.out.println(f.getPath());        }else if(f.isDirectory()){ //如果是文件夹             System.out.println(f.getPath());            if(f.listFiles()!=null) {                 File[] fs=f.listFiles(); //得到下面所有的文件对象                for(File fa:fs){                 prints(fa);                }            }        }    }     

Hibernate（二）：一对多（one-to-many） 配置及基本CURD  以下是基于省份对应多个城市的映射配置及级联CURD例子 hibernate.cfg.xml<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate</property> <property name="hibernate.connection.password">root</property> <property name="hibernate.connection.username">root</property> <property name="show_sql">true</property><!-- 显示sql --> <property name="format_sql">true</property><!-- 格式化sql --> <mapping resource="club/lygangdai/entity/Province.hbm.xml"/> <mapping resource="club/lygangdai/entity/City.hbm.xml"/> </session-factory> </hibernate-configuration> Province.javapackage club.lygangdai.entity; import java.util.HashSet; import java.util.Set; /** * @ClassName: Province * @Description: TODO(省份类) * @author Uncle * @date 2018年8月7日 上午9:50:48 * */ public class Province { private int pid; //id private String pname; //省份 private Set<City> cities = new HashSet<City>();//城市集合 /** * @Description: TODO(这里用一句话描述这个类的作用) * @param pid * @param pname */ public Province(int pid, String pname) { super(); this.pid = pid; this.pname = pname; } /** * @return cities */ public Set<City> getCities() { return cities; } /** * @param cities 要设置的 cities */ public void setCities(Set<City> cities) { this.cities = cities; } /** * @Description: TODO(这里用一句话描述这个类的作用) */ public Province() { super(); } /** * @return pid */ public int getPid() { return pid; } /** * @param pid 要设置的 pid */ public void setPid(int pid) { this.pid = pid; } /** * @return pname */ public String getPname() { return pname; } /** * @param pname 要设置的 pname */ public void setPname(String pname) { this.pname = pname; } /* (非 Javadoc) * @Title: toString * @Description: TODO(这里用一句话描述这个方法的作用) * @return * @see java.lang.Object#toString() */ @Override public String toString() { return "Province [pid=" + pid + ", pname=" + pname + "]"; } } Province.hbm.xml<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <!-- Generated 2018??8??2?? ????1:45:51 by Hibernate Tools 3.5.0.Final --> <hibernate-mapping> <!--映射实体类对象，生成默认为province的数据库表,lazy关闭延迟加载--> <class name="club.lygangdai.entity.Province" table="province" lazy="false"> <id name="pid" type="int"> <column name="pid"></column> <!-- 自增 --> <generator class="native"></generator> </id> <property name="pname" type="java.lang.String"> <column name="pname"></column> </property> <!-- province里的set集合，对应的city表 ,inverse关联关系交给多端维护--> <set name="cities" table="city" cascade="all-delete-orphan" inverse="true"> <!-- city表中与province对应的列，city表外键 pid--> <key column="pid"></key> <!-- 对应多端实体类 --> <one-to-many class="club.lygangdai.entity.City"/> </set> </class> </hibernate-mapping> City.javapackage club.lygangdai.entity; /** * @ClassName: city * @Description: TODO(城市类) * @author Uncle * @date 2018年8月7日 上午9:40:17 * */ public class City { private int cid; //id private String cname; //城市 private int pid; //省份id private Province p; //省份对象 /** * @Description: TODO(这里用一句话描述这个类的作用) */ public City() { super(); } /** * @Description: TODO(这里用一句话描述这个类的作用) * @param cid * @param cname * @param pid */ public City(int cid, String cname, int pid) { super(); this.cid = cid; this.cname = cname; this.pid = pid; } /** * @return p */ public Province getP() { return p; } /** * @param p 要设置的 p */ public void setP(Province p) { this.p = p; } /** * @return cid */ public int getCid() { return cid; } /** * @param cid 要设置的 cid */ public void setCid(int cid) { this.cid = cid; } /** * @return cname */ public String getCname() { return cname; } /** * @param cname 要设置的 cname */ public void setCname(String cname) { this.cname = cname; } /** * @return pid */ public int getPid() { return pid; } /** * @param pid 要设置的 pid */ public void setPid(int pid) { this.pid = pid; } /* (非 Javadoc) * @Title: toString * @Description: TODO(这里用一句话描述这个方法的作用) * @return * @see java.lang.Object#toString() */ @Override public String toString() { return "city [cid=" + cid + ", cname=" + cname + ", pid=" + pid + "]"; } } City.hbm.xml<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <!-- Generated 2018??8??2?? ????1:45:51 by Hibernate Tools 3.5.0.Final --> <hibernate-mapping> <!--映射实体类对象，生成默认为city的数据库表,lazy关闭延迟加载--> <class name="club.lygangdai.entity.City" table="city" lazy="false"> <id name="cid" type="int"> <column name="cid"></column> <generator class="native"></generator> </id> <property name="cname" type="java.lang.String"> <column name="cname"></column> </property> <!-- 一端的对象，对应外键 pid --> <many-to-one name="p" class="club.lygangdai.entity.Province" column="pid"></many-to-one> </class> </hibernate-mapping>HibernateTest.javapackage test; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.Transaction; import org.hibernate.cfg.Configuration; import org.junit.Test; import club.lygangdai.entity.Card; import club.lygangdai.entity.City; import club.lygangdai.entity.Person; import club.lygangdai.entity.Province; /** * @ClassName: HibernateTest * @Description: TODO(这里用一句话描述这个类的作用) * @author Uncle * @date 2018年8月7日 上午8:58:50 * */ public class HibernateTest { @Test public void hibernateTest() { //读取配置文件 Configuration configuration = new Configuration().configure(); //创建工厂 SessionFactory sessionFactory = configuration.buildSessionFactory(); //session Session session = sessionFactory.openSession(); //事务 Transaction transaction = session.beginTransaction(); //级联关系 //一对多----------------------------------------------------------------------------------- //添加 // Province p = new Province(); // p.setPname("湖南"); // // City c1 = new City(); // c1.setCname("长沙"); // City c2 = new City(); // c2.setCname("株洲"); // City c3 = new City(); // c3.setCname("湘潭"); // // p.getCities().add(c1); // p.getCities().add(c2); // p.getCities().add(c3); // // c1.setP(p); // c2.setP(p); // c3.setP(p); // session.save(p); //修改 //查询省份修改城市 // Province p = session.get(Province.class, 2); // for(City c : p.getCities()){ // if(c.getCname().equals("湘潭")) { // c.setCname("邵阳"); // } // } // session.save(p); //得到城市修改省份 // City c = session.get(City.class, 1); // c.setCname("湘潭"); // c.getP().setPname("湖北"); // session.save(c); //删除 // 一断的 记得配置inverse="true" 否则删除失败 <set name="cities" table="city" cascade="all-delete-orphan" inverse="true"> // Province p = session.get(Province.class, 2); // System.out.println(p); // session.delete(p); //提交 transaction.commit(); //关闭session及sessionFactory session.close(); sessionFactory.close(); } }     

Hibernate简介 ORM 原理ORM（Object Relational Mapping）或O/RM,或O/R Mapping，称为:对象/关系映射 ORM 是通过使用描述对象和数据库之间映射的元数据，将java中的对象自动持久化到关系数据库中，ORM是对象持久化的核心。目前常见的ORM技术有Hibernate和Sun JPA。为什么要使用ORM   面向对象的开发方法时当今企业级应用开发环境中的主流开发方法，关系数据时企业级应用环境中永久存放数据的主流数据存储系统。  传统JDBC开发问题：开发繁琐，重复劳动。    Hibernate简述   Hibernate 是一个开源的ORM框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库建立映射关系，是一个全自动的ORM框架   Hibernate可以自动生成SQL 语句、自动执行，使得JAVA程序员可以随心所欲的使用对象编程思维来操纵数据库。可以在应用EJB的J2EE架构中取代CMP,完成数据持久化的重任。 JDBC与Hibernate的比较JDBC的速度最快，因为它是直连数据库，但是操作麻烦。Hibernate是DAO层的框架，专门链接数据库，简化封装了JDBC，同时牺牲了一部分性能，所以速度上Hibernate比JDBC慢很多。    

==和equals方法究竟有什么区别？ 相同点：都是用来比较两个变量的值是否相等。不同点： 在值类型（基本数据类型）中，==比较的是内容。 在引用类型中，==比较的是地址，equals比较的是内容。  ==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如Objet obj = new Object();变量obj是一个内存，new Object()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。equals方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如：对于下面的代码： String a=new String("foo");String b=new String("foo"); 两条new语句创建了两个对象，然后用a，b这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即a和b中存储的数值是不相同的，所以，表达式a==b将返回false，而这两个对象中的内容是相同的，所以，表达式a.equals(b)将返回true。在实际开发中，我们经常要比较传递进来的字符串内容是否等，例如，String input =…;input.equals(“quit”)，许多人稍不注意就使用==进行比较了，这是错误的，随便从网上找几个项目实战的教学视频看看，里面就有大量这样的错误。记住，字符串的比较基本上都是使用equals方法。如果一个类没有自己定义equals方法，那么它将继承Object类的equals方法，Object类的equals方法的实现代码如下： boolean equals(Object o){ return this==o;} 这说明，如果一个类没有自己定义equals方法，它默认的equals方法（从Object类继承的）就是使用==操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用==会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须覆盖equals方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。