(原版)马士兵JAVA框架HIBERNATE学习笔记

合集下载

Java学习笔记_马士兵老师视频教学的笔记

Java学习笔记学习Java首先要配置环境变量，在电脑属性的高级中，点击环境变量，classpath 中有一英文句号“.”后跟一个分号，表示当前路径的意思。

由第一个程序Helloworld为例说明Java的基本运行代码：public class HelloWorld {public static void main(String args[]) {System.out.println("Hello, World!");}}在Java中只能允许有一个公共类，此区别于C++。

还有Java的写作风格与C和C++有很大区别。

下面细谈Java的基本语法，与其他语言类似，Java每一条语句都以“；”结束。

1.short byte char 之间不会自动转换，他们运算时首先转换为int 然后进行运算；boolean不会进行转换；如：byte b1;byte b2;byte b3=byte(b1+b2);b1+b2运算后是int 类型，可以byte a=1;//可以把数值直接赋值不超范围，（-128~127）float f1=1.234f;long l1=300000000L;f和L一定加上；2.System.out.println( );//输出后换行System.out.print( );//输出后不换行&&和&的区别：表达式1 && 表达式2 只要表达式1 错误，后不再计算，表达式1 & 表达式2 就算表达式1错误表达式2也会计算。

+既可以作为加号，也可以作为连接符，即左右都是字符串，当有一个是字符串，系统默认把另一个转化为字符串再处理。

例如：System.out.println(“c=”+ c);打印时，无论任何类型，都先转换为字符型，再进行打印。

3.聚合关系，就是包含关系，实现关系就像虚基类，在派生类中实现。

4.定义成员变量可以初始化，若不则自动初始化(可以直接在成员变量的定义时初始化)；但局部变量一定要自己初始化，boolean类型默认为false，其他默认为0；在main中调用函数时，只要定义了构造函数并且初始化，就一定要把实参的值写到函数里，不能少参数。

马士兵_J2SE_第二章_基础语法_个人学习笔记

第二章基础语法1. 成员变量：类体内方法体外声明的变量局部变量：方法体内声明的变量重要：变量出了它所在的大括号就不起作用了，反之只要是在它的大括号内任何地方都起作用。

TestConvert.javapublic class TestConvert {public static void main(String arg[]) {int i1 = 123;int i2 = 456;double d1 = (i1+i2)*1.2;//系统将转换为double型运算float f1 = (float)((i1+i2)*1.2);//需要加强制转换符byte b1 = 67;byte b2 = 89;byte b3 = (byte)(b1+b2);//系统将转换为int型运算，需//要强制转换符System.out.println(b3);//结果：-100double d2 = 1e200;float f2 = (float)d2;//会产生溢出System.out.println(f2);//infinity(无限)float f3 = 1.23f;//必须加flong l1 = 123;long l2 = 30000000000L;//必须加lfloat f = l1+l2+f3;//系统将转换为float型计算long l = (long)f;//强制转换会舍去小数部分（不是四舍五入）}}TestConvert2public class TestConvert2 {public static void main(String[] args) {int i=1,j=12;float f1=(float)0.1; //0.1ffloat f2=123;long l1 = 12345678,l2=8888888888L;double d1 = 2e20,d2=124;byte b1 = 1,b2 = 2,b3 = 127;j = j+10;i = i/10;i = (int)(i*0.1);char c1='a',c2=125;byte b = (byte)(b1-b2);char c = (char)(c1+c2-1);float f3 = f1+f2;float f4 = (float)(f1+f2*0.1);double d = d1*i+j;float f = (float)(d1*5+d2);}}Fab.javapublic class Fab {public static void main(String[] args) {System.out.println(f(-9));}public static long f(int index) {if(index < 1) {System.out.println("invalid parameter!");return -1;}if(index == 1 || index == 2) {return 1;}long f1 = 1L;long f2 = 1L;long f = 0;for(int i=0; i<index-2; i++) {f = f1 + f2;f1 = f2;f2 = f;}return f;}}。

马士兵java基础笔记 pdf版面向对象部分

public class Test{ public static void main(String args[]){ Test test = new Test(); int date = 9; BirthDate d1= new BirthDate(7,7,1970); BirthDate d2= new BirthDate(1,1,2000)(1); test.change1(date)(4); test.change2(d1);(7) test.change3(d2);
b.setDay(22)，把 b 指向的值改变了，这次真的变了！
方法执行完后，b 消失，d2 的值变了。
四. 方法重载类中可以定义相同名字但参数不同的方法。
五. this 关键字 this 指向对象自身的引用。
在类的方法定义中使用 this 关键字代表使用该方法的对象的引用。当必须指出当前使用方法的对象是谁时要使用 this 有时使用 this 可以处理方法中成员变量和参数重名的情况 this 可以看作是一个变量，它的值是当前对象的引用
_id:1
age = _age; }
_age:25
public static void main(String[] args) {
Person tom = new Person(1, 25); } }
tom:XXX Stack
id:1 age:25
Heap
例子：
class BirthDate { private int day; private int month; private int year; public BirthDate(int d, int m, int y) { //构造方法 day = d; month = m; year = y; }

马士兵hibernate学习笔记(文字整理版)

2 Hibernate原理模拟 - 什么是O/R Mapping以及为什么要有O/R Mapping (5)3 常见的0/R框架(了解) (5)4 hibernate基础配置（重点） (5)5 ID生成策略（重点 AUTO) (5)6 Hibernate核心开发接口介绍（重点） (5)7 对象的三种状态（了解） (5)8 关系映射（重点） (5)9 Hibernate査询（HQL) (5)10 在Struts基础上继续完善BBS200 (5)11 性能优化（重点） (5)12 补充话题 (5)风格 (5)1 先脉络，后细节 (5)2 先操作，后原理 (5)3 重Annotation,轻xml配置文件 (5)资源 (5)1 http://www. (5)2 hibernate zh_CN文档 (5)3 hibernate annotation references (5)环境准备 (5)1 下载hibernate-distribution-3.3.2.GA-dist (5)2 下载hibernate-annotations-3[1].4.0.GA (5)3 注意阅读hibernate compatibility matrix(hibernate 网站download) (5)4 下载slf4jl.5.8 (6)Hibernate HelloWorld (6)1 建立新java 项目,名为hibernate_0100_HelloWorld (6)2 学习建User-library-hibernate,并加入相应的jar包 (6)3 引入mysql的JDBC驱动包 (6)4 在mysql中建立对应的数据库以及表 (6)5 建立hibernate 配置文件hibernate.cfg.xml (6)6 建立Student 类 (6)7 建立Student 映射文件 Student.hbm.xml (6)8 将映射文件加入到hibernate.cfg.xml中 (6)9 写测试类Main,在Main中对Student对象进行直接的存储测试 (6)10 FAQ： (6)11 Note: (6)12 建立能力 (7)建立 Annotation 版本的 HelloWorld (7)1 创建teacher 表，create table teacher (id int primary key, name varhcar(20), title varchar(lO)); (7)2 创建Teacher 类 (7)3 在hibernate lib 中加入annotation的jar包 (7)4 参考Annotaion文档建立对应的注解 (7)5 在hibernate.cfg.xml中建立映射<mapping class:.../〉 . (7)6 参考文裆进行测试（注意文裆中缺少configure()的小bug) (7)7 FAQ: @不给提示 (7)What is and Why 0/R Mapping (7)1 JDBC操作数据库很繁琐 (7)2 Sql语句编写并不是面向对象的 (7)3 可以在对象和关系表之间建立关联来简化编程 (7)4 0/R Mapping 简化编程 (7)5 0/R Mapping跨越数据库平台 (7)6 Hibernate_0200_OR_Mapping_Simulation (7)2 toplink (8)3 jdo (8)4 JPA (8)Hibernate基础配置 (8)1 对应项目：Hibernate_0300_BasicConfiguration (8)2 介绍MSQL的图形化客户端 (8)3 hibernate.cfg.xml: hbni2ddl.auto (8)4 搭建日志环境并配置显示DDL语句 (8)5 搭建jUnit环境 (8)6 hibernate.cfg.xml：show_sql (8)7 hibernate.cfg.xml：format_sql (8)8 表名和类名不同,对表名进行配置 (8)9 字段名和属性相同 (8)10 字段名和属性名不同 (8)11 不需要psersistence的字段(不用列) (8)12 映射日期与时间类型，指定时间精度 (8)13 映射枚举类型( 比较少用) (9)14 字段映射的位置（field或者get方法） (9)15 @Lob (9)16 课外：CLOBBLOB类型的数据存取 (9)17 课外：Hibernate自定义数据类型 (9)18 hibernate 类型 (9)ID生成策略 (9)1 对应项目：hibernate_0400_ID (9)2 注意： (9)3 xml生成id (9)4 注解方式：@GeneratedValue (9)5 FAQ; (10)6 联合主键 (10)核心幵发接口介绍 (12)1 hibernate_0500_CoreAPI (12)2 Hibernate API文档需要单独下载 (12)3 Configuration (12)4 SessoinFactor (12)5 Session (12)6 SchemaExport (自动建表) (13)7 Query 接口 (13)8 Note： (13)三种对象状态 (14)1 上一个 project (14)2 三种状态的区分关键在于 (14)3 三种状态： (14)4 对这三种状态需要关注的问题是在该状态下如果进行数据库的操作会发生什么结果，比如改变属性的 (14)关系映射(重要) (15)对象之间的关系 (15)1 这里的关系映射指的是对象之间的关系，并不是指数据库的关系，本章解决的问题是当对象之间处于 (15)2 简化问题： (15)3 —对一 (15)4 —对多 (15)5 组件映射 (15)1 一对一单向外键关联 (16)2 一对一双向外键关联 (16)3 一对一单向主键关联（不重要） (17)4 一对一双向主键关联（不重要） (17)5 联合主键 (17)组件映射 (17)1 项目：hibernate_1100_component (17)2 对象关系：一个对象是另外一个对象的一部分 (17)3 数据库表：一张表 (17)4 annotation: @ Embeddable @Embbeded (17)5 xml: 使用<component,例如: (18)多对一与一对多 (18)1 多对一单向关联 (18)2 一对多单向关联 (19)3 一对多（多对一）双向关联 (19)多对多 (20)1 单向关联： (20)2 双向关联： (21)关联关系中的CRUD_Cascade_Fetch (21)1 hibernate_1700_one2many_many2one_bi_crud (21)2 设定cascade以设定在持久化时对于关联对象的操作（CUD，R归Fetch管） (21)3 cascade仅仅是帮我们省了编程的麻烦而已，不要把它的作用看的太大 (21)4 铁律：双向关系在程序中要设定双向关联 (22)5 铁律：双向mappedBy (22)6 fetch (22)7 Update时@ManyToOne()中的cascade参数关系 (22)8 Delete时@ManyToOne()中的cascade关系 (22)9 O/RMapping 编程模型 (23)10 要想删除或者更新先做load,除了精确知道ID之外 (23)11 如果想消除关联关系，先设定关系为null.再删除对应记录，如果不删记录，该记录变成垃圾数据 (23)12 练习：多对多的CRUD (23)关系映射总结 (24)1 什么样的关系，设计什么样的表，进行什么样的映射 (24)2 CRUD,按照自然的理解即可（动手测试） (24)集合映射（不太重要） (24)1 项目名称：hibernate_1800_Collections_Mapping (24)2 Set (24)3 List (与Set差不多多个@OrderBy) (24)4 Map (24)继承映射（不太重要） (24)1 三种方式 (24)作业: (24)1 学生课程、分数的设计(重要) (24)2 设计： (25)3 树状结构的设计（至关重要） (25)Hibernate 查询(Query Language) (26)HQL vs EJBQL (26)1 NativeSQL >HQL.> EJBQL(JPQL 1.0) > QBC(Query By Criteria) > QBE(Query By Example)" 262 总结：QL应该和导航关系结合，共同为査询提供服务。

Hibernate课堂笔记

Hibernate部分学习笔记讲师:梁建全liangjq@目录Hibernate部分学习笔记 (1)Day01 (5)一、Hibernate基本概念 (5)1、Hibernate是什么，有什么作用和好处 (5)2、Hibernate实现原理 (5)3、Hibernate框架主要结构 (5)二、Hibernate基本应用 (6)1、Hibernate使用步骤 (6)三、映射类型 (9)1、Hibernate映射类型主要有以下几种： (9)四、主键生成 (10)Day02 (11)一、Hibernate框架的基本特性 (11)1、Hibernate一级缓存 (11)A.一级缓存的特点 (11)B.一级缓存的好处 (11)C.使用建议 (11)2、Hibernate对象持久性 (13)3、Hibernate延迟加载 (14)A.针对于以下方法，Hibernate默认使用延迟加载机制： (14)B.Session的get和load方法区别： (14)C.延迟实现原理 (15)D.Hibernate框架如何动态生成一个代理类 (15)E.使用建议 (15)二、Hibernate综合练习 (15)前期案例：任务列表示例重构（采用Struts2+Hibernate） (15)A.Hibernate前期准备 (15)B.为了更好使用一级缓存，采用ThreadLocal封装Session (16)C.采用Hibernate重构ProjectDAO (17)D.为了支持延迟加载API，采用拦截器实现OpenSessionInView模式 (18)Day03 (20)一、什么是关联映射，有什么好处 (20)二、一对多关联映射 (20)示例：d_order和d_item存在一对多的业务关系 (20)一对多关系映射的实现步骤： (20)三、多对一关联映射 (21)多对一关系映射实现步骤： (21)四、关联操作 (22)1、关联查询 (22)2、利用lazy属性控制延迟加载 (22)3、级联操作（采用关系级联方式进行添加、删除、更新操作） (22)A.在关联属性映射部分添加cascade属性，可以指定以下属性 (22)B.Inverse属性的作用 (22)C.级联添加 (23)D.级联删除 (23)Day04 (24)一、如何使用Myeclipse生成映射文件和实体类? (24)1、如何根据DB生成实体类和映射文件 (24)A.利用Myeclipse追加Hibernate框架步骤: (24)B.利用Myeclipse根据表生成实体类和映射文件 (26)二、多对多关系映射 (29)三、继承关系映射 (30)1、继承关系映射（1） (30)A.首先将Book继承自Product类 (30)B.修改Book.hbm.xml描述信息 (30)2、继承关系映射(2)---理解 (31)Day05 (33)一、其他映射 (33)1、List集合映射 (33)2、formula子查询映射 (33)3、Component组件映射 (34)4、联合主键映射 (35)案例：采用联合主键映射+组件映射对t_person表进行操作。

JAVA笔记(根据马士兵的java视频整理)

JAVA视频教程尚学堂---手把手教程Call:86-主讲教师马士兵SCM系统--------Java+VC跨平台(电信宽带运营平台-------Java+WEB(J2EE)跨平台远程教学平台----Java+WEB(tomcat)VOD视频监控-----VCERP视频会议---------VC新闻发布系统-----Java+XML（模板）网上商城课堂内容、教学方法、学习方法、预备知识、教学资源JAVA基础贯穿数据结构的知识（时间复杂度、链表）---非常重要语法基础【变量、循环、分支】最核心的东西—原理--学好OO【面向对象是最重要的】有新东西学是好事----个人价值Exception 从Java Web开始，框架巨多无比Array【数组】基础类、常用类I/O StreamCollection/Generic【集合类】Thread【线程】TCP/UDP【网络底层】GUI【Graphic User Interface 图形化用户接口窗口】Meta Data【以后讲，与紧密相关】Regular Expression【正规表达式】JDK初步Java Web编程【主攻一个框架---讲原理，略讲其他框架】针对Web程序J2EE【一套标准,包含Java Web 、JDPC、JSP、SP、JB/开源框架—就分步式来说，目前(2005)无东西与之抗衡】（比较,,）企业级应用J2ME移动设备移动增值SP运营商3G,2.5G,要火爆起来【网络先铺起来，应用才能上来；3G的网络还没有铺开、火爆起来，讲3G的应用超前了】巨无霸式的教学理论举例理论回顾练习讲解【三片面包加两片肉】注重结合工程实践【完全结合】注重传授自学能力【自学的东西相当重要，授人以鱼，不如授人以渔；慢慢学会掌握一定基础后才有，灌输、背，融成血液里的一部分，心中无剑，手中有剑—前提—心中有剑手中也有剑；时间短，强度大，该背就背】个人能力分三个层次知识学习前人的知识---学习能力的一个表现，被动地接受—接受能力{自己学习了知识后考虑如何去应用，去---学习解决问题的方法【类似问题遇到过】灵活运用学到的知识【碰到什么问题采用什么方法】解决问题的思路【最高层次】创造解决问题的方法【思路掌握了，遇到新问题，自己拓展一条思路，解决问题，不可能一口吃成一个胖子，沿着这三个层次一点一点往上升首先打造自己学习知识的能力，先把该掌握的知识掌握了，再谈如何应用---如何教---教大家写项目每一个知识教太深—给项目留得时间特别短---不合适；自学一些东西，慢慢去培养解决问题的思路，试着朝这个方向去培养，工作后慢慢遇到新问题使劲去思考了积累起来逐渐会有这个能力，灵活一点、再灵活一点！基础知识要背—灵活应用的东西不能背，无一定之规，在实践中慢慢锻炼—实践的越多—敲的代码越多（掌握思路后自主敲代码，哪怕敲不出来再看别人的思路—收获远远不一样，学习要自主一点，多思考思路才能开阔—无捷径，努力锻炼自己的就业能力。

马士兵vip课笔记

马士兵vip课笔记
马士兵VIP课笔记
1. 课程概述
马士兵的VIP课程是一个全面的编程培训项目，涵盖了从基础到高级的各类编程知识和技能。

该课程强调实战编程，注重培养学员的实际项目开发能力。

通过学习此课程，学员可以掌握多种编程语言和技术，为未来的职业发展打下坚实的基础。

2. 课程内容
•基础概念：课程首先介绍了编程的基本概念，如变量、数据类型、控制结构等。

•面向对象编程：深入探讨了面向对象编程的概念，包括类、对象、继承和多态等。

•高级编程技术：涵盖了如泛型、反射、异步编程等高级编程技术。

•框架与库：介绍了多个主流的编程框架和库，如Spring、Django等。

•实战项目：课程以多个实战项目作为结尾，让学员在实际操作中巩固所学知识。

3. 课程特色
•实战导向：课程强调实战编程，注重培养学员解决实际问题的能力。

•内容全面：课程内容涵盖了从基础到高级的各类编程知识和技能，满足不同层次学员的需求。

•互动性强：课程中设置有多个互动环节，鼓励学员与老师和同学进
行交流和讨论。

•社区支持：提供了一个强大的社区支持，学员可以在社区中寻求帮助和分享经验。

4. 总结
马士兵的VIP课程是一个非常全面且实战导向的编程培训项目。

通过学习此课程，学员可以系统地掌握编程知识和技能，为未来的职业发展打下坚实的基础。

如果你是一位编程爱好者或者想要在编程领域有所建树，那么这门课程是你不容错过的选择。

JAVA黑马程序员Hibernate5框架学习笔记及应用

3.2 CRM 持久层技术分析
本 CRM 系统使用 javaEE 技术并按照标准三层架构实现，三层为单向依赖，即 web 层依赖业务层、业务层依赖持久层，持久层不依赖 web 层和业务层，通常建议先实现持久层，在本课程我们把重点放在持久层的设计开发上。
3.2.1 数据库
根据系统规模大小选择数据库，本 CRM 系统选择 mysql5 作为数据库。安装 Mysql5 数据库过程略。
//加载数据库驱动 Class.forName("com.mysql.jdbc.Driver");
//通过驱动管理类获取数据库链接
connection =
DriverManager.getConnection("jdbc:mysql://localhost:3306/hibernate?characterEncodin
持久层使用关系数据库则一般关系数据库本身就提供了事务控制机制。
3.1.4 持久层
负责数据持久化，包括数据层即数据库和数据访问层，数据库是对数据进行持久化的载体，数据访问层是业务层和持久层交互的接口，业务层需要通过数据访问层将数据持久化到数据库中。技术实现：
数据库访问在 java 中使用 jdbc 接口。数据库根据项目需求去选择。
//通过驱动管理类获取数据库链接
connection =
DriverManager.getConnection("jdbc:mysql://localhost:3306/hibernate?characterEncodin
g=utf-8", "root", "mysql");
//定义sql语句 ?表示占位符

hibernate4学习笔记

Hibernate4学习笔记本人全部以自学为主，在网上收集各种学习资料，总结归纳学习经验，现将学习路径给予大家分享。

此次学习的hibernate的版本是：hibernate-release-4.2.4.Final（截止2015年7月31日最新版），JAVA的版本是：java8.0，使用的开发工具是：Eclipse Mars Release (4.5.0)。

第一天：Hibernate4基础知识和HelloWorld简单编程Hibernate是一种半成品ORM框架，对数据库持久化操作，程序员对数据库的操作转换成对对象的操作。

ORM 采用元数据来描述对象-关系映射细节, 元数据通常采用XML 格式, 并且存放在专门的对象-关系映射文件中。

HelloWorld简单编程1、准备Hibernate环境（1）导入Hibernate的Jar包，如下：（2）导入Mysql驱动包，我用的数据库是：Mysql 5.0，数据库驱动包如下：以上所有Jar加完毕之后，需要加入到Eclipse自身系统里面，具体如下：以上操作完毕之后，Hibernate的环境就算搭建完毕，下面就可以进一步操作。

2、配置hibernate.cfg.xml文件，主要是对数据库的连接，具体如下：<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd "><hibernate-configuration><session-factory><property name="ername">root</property><property name="connection.password">mysql</property><propertyname="connection.driver_class">com.mysql.jdbc.Driver</property> <property name="connection.url">jdbc:mysql:///Test(或者：jdbc:mysql://localhost:3306/Test)</property><propertyname="dialect">org.hibernate.dialect.MySQLInnoDBDialect</property> <property name="show_sql">true</property><property name="format_sql">true</property><property name="hbm2ddl.auto">update</property></session-factory></hibernate-configuration>3、编写一个实例类News.java，具体代码如下：package com.hibernate.helloworld;import java.sql.Date;public class News {private Integer id;private String title;private String author;private Date date;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}public String getAuthor() {return author;}public void setAuthor(String author) {this.author = author;}public Date getDate() {return date;}public void setDate(Date date) {this.date = date;}public News(String title, String author, Date date) {super();this.title = title;this.author = author;this.date = date;}public News(){}@Overridepublic String toString() {return"News [id="+ id+ ", title="+ title+ ", author="+ author + ", date=" + date + "]";}}4、创建News.hbm.xml配置映射文件，具体代码如下：<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping><class name="com.hibernate.helloworld.News"table="NEWS"> <id name="id"type="ng.Integer"><column name="ID"/><generator class="native" /></id><property name="title"type="ng.String"><column name="TITLE"/></property><property name="author"type="ng.String"><column name="AUTHOR"/></property><property name="date"type="java.sql.Date"><column name="DATE"/></property></class></hibernate-mapping>5、将映射文件News.hbm.xml指定到hibernate.cfg.xml配置文件里面，即在hibernate.cfg.xml文件里加入一行映射代码，具体如下：6、创建hibernate API操作测试类（Juit测试），验证hibernate的优势效果，具体代码如下：package com.hibernate.helloworld;import java.sql.Date;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.hibernate.cfg.Configuration;import org.hibernate.service.ServiceRegistry;import org.hibernate.service.ServiceRegistryBuilder;import org.junit.Test;public class HibernateTest {@Testpublic void test() {//1. 创建一个 SessionFactory 对象SessionFactory sessionFactory=null;//1). 创建 Configuration 对象: 对应 hibernate 的基本配置信息和对象关系映射信息Configuration configuration=new Configuration().configure();//4.0 之前这样创建//sessionFactory=configuration.buildSessionFactory();//2). 4.0以后创建一个 ServiceRegistry 对象: hibernate 4.x 新添加的对象//hibernate 的任何配置和服务都需要在该对象中注册后才能有效.ServiceRegistry serviceRegistry=newServiceRegistryBuilder().applySettings(configuration.getProperties() ).buildServiceRegistry();sessionFactory=configuration.buildSessionFactory(serviceRegistry) ;//2. 创建一个 Session 对象Session session=sessionFactory.openSession();//3. 开启事务Transaction transaction=session.beginTransaction();//4. 执行保存操作News news = new News("Java12345", "ATGUIGU", new Date(new java.util.Date().getTime()));session.save(news);//5. 提交事务mit();//6. 关闭 Sessionsession.close();//7. 关闭 SessionFactory 对象sessionFactory.close();}}7、测试结果如下：（1）数据库里面的结果如下：（2）Eclipse下的语句生成如下：以上就是简单Hibernate的测试，总结：1、不需要在数据库里面创建任何数据，由hibernate 自动生成；2、代码简单易理解，不复杂，测试数据只需要先创建以下几个步骤：SessionFactory-→Session-→Transaction-→session操作数据库-→提交-→关闭；3、不需要写SQL 语句，从头到尾没有写一条SQL语句，反而Hibernate帮我们生成SQL语句。

马士兵 J2SE基础概念总结

基础概念(J2SE)(1_Java简介,2_基础语法)1.Java是解释型语言：java需要先编译为.class字节码文件，在执行时用解释器解释成操作系统能识别的文件。

需要经过两次操作。

Java：编译*.java源代码文件---编译器编译---*.class字节码文件，执行*.class字节码文件----解释器解释----操作系统能识别的文件C/C++: 编译 .C 源代码文件----编译器编译----*.exe字节码文件, 执行*.exe字节码文件----操作系统能识别的文件。

2.基础类型的包装类基础类型分配到栈，引用类型分配到堆基础类包装类int Integerchar Charaterboolean Boolean…转换：1. 当需要把String 转换为基础数据类型时，使用对应的基础数据类型的包装类里面的方法。

列：int a = Integer.parseInt(s);2. 将基本类型数据转换为String:int a = 2;String m = String.valueOf(a);3. String转char:String s = “Xforce”char a = s.charAt(1);(3_面向对象编程)重点：1.代码内存分析：06_内存解析_1, 07_内存解析_2，08_内存解析_3，14_TestCircle程序分析_1, 15_TestCircle程序分析_2, 15_TestCircle 程序分析_2.2.动态绑定和多态39_多态_1.avi 40_多态_2.avi 内存分析见39_多态_1.avi TestPolymoph\ Test.java父类引用指向子类对象解释：37_对象转型_1.avi3.抽象类、抽象方法4.接口一、对象和类的概念1.类是同种对象的集合与抽象，类中定义了这一类对象所应具有的静态和动态属性。

二、面向对象设计思想和步骤:(1)分析问题中有哪些类那些对象(2)分析这些对象中应该具有的属性和方法(3)分析类与类之间的关系三、Java类的定义四、局部变和成员变量局部变量:方法或语句块内部(方法的参数叫局部变量)(小)( 必须赋初试值才可以使用)成员变量:方法外部、类的内部(大), 不用初始化，java系统会给你赋初始值五、引用类型（C中的指针,占两块内存）六、构造函数构造函数是定义在java类中的一个用来初始化对象的函数1.构造函数名字与类的名字相同，大小写也保持一致2.使用new+构造方法创建一个新的对象3.构造函数与类同名切没有返回值。

java-hibernate笔记(讲义)-【尚学堂马士兵老师】

java-hibernate笔记(讲义)-【尚学堂马士兵老师】知识点终结：1 新建项目2 学习建立user-library-hibernate,并加入相应的jar包a项目右键-build path-configure build path-add libraryb选择user-library,在其中新建library,命命为hibernatec 在该library中加入hibernate所需要的jar包hibernate3.3.2/hibernate3.jar/lib/required目录下的所有包6个Sl4j-nop jar3 引入mysql的JDBC驱动包4 在MYSQL中建数据库和相应的表student(id,name,age)5 建立hibernate配置文件hibernate.cfg.xml参考文档中COPY,修改对应的数据库连接,6 建立student类7 建立映射文件Student.hbm.xml 参考相应文档8 将映射文件加到hibernate-cfg.xml中搭建日志环境并配置显示DDL语句slf的实现:slf4j nodep ,log4j ,jdk logging api ,apache common-log.slf4j.nop.jar是slf-api.jar其相应的接口实现把slf的接口对到log4j的实现,在user library中hibernate,把slf的实现slf4j-nop-1.5.8.jar去掉,添加log4j的实现log4j-1.2.15.jar,再添加一个slf-api和log4j转换器slf4j-log4j12-1.5.8.jar.把slf的接口转换成log4j的接口.最后添加一个log4j的配置文件log4j.properties利用HIBERNA TE导出数据库建表//读取配置文件hibernate.cfg.xmlConfiguration cfg=new AnnotationConfiguration().configure();(有注解时使用AnnotationConfiguration),configure()可以手动指定配置文件名称. Configuration cfg=new Configuration(),会默认读取hibernate.properties文件//创建schemaExport对象import org.hibernate.tool.hbm2ddl.SchemaExport;SchemaExport export=new SchemaExport(cfg);//创建数据库表export.create(true, true);对象映射(采用Annotation注解方式)1 建表Create table teacher(id int primary key,name varchar(20),title varchar(20));2 创建teacher类,并进行注解@import javax.persistence.Entity;import javax.persistence.Id;在bean中加注解@ Entity,@Id(加在getId()上面)3 在hibernate中加入annotation相应的jar包hibernate-annotations.jar/lib目录下加入相应的包ejb3-persistence.jar, hibernate-commons-annotations.jar注意:annotation文档中并没有提到hibernate-annotations.jar包4 参考annotation文档建立对应的注解5 在hibernate.cfg.xml中建立映射<mapping class=”com.xx.xx”/>6 示例//AnnotationConfiguration;Configuration cfg=new AnnotationConfiguration();SessionFactory sf=cfg.configure().buildSessionFactory();Session session=sf.openSession();session.beginTransaction();session.save(t);//session.getTransaction().commit();session.close();sf.close();对象映射(采用配置文件方式)1 在相应的类中建立对应的配置文件.例如Student类对应的配置文件Student.hbm.xml<hibernate-mapping package="com.model"><class name="Student" table=" Student" ><id name="id" column="id"></id><property name="name" column="name" /><property name="age" column="age" /></class></hibernate-mapping>2 在hibernate.cfg.xml中添加该映射文件Student.hbm.xml即可<mapping resource="com/model/Student.hbm.xml"/>注意包名的写法3 示例//读取配置文件hibernate.cfg.xmlConfiguration cfg=new Configuration().configure();//创建SessionFactorySessionFactory sf=cfg.configure().buildSessionFactory();//创建sessionSession session=sf.openSession();session.beginTransaction();session.save(s);session.getTransaction().commit();session.close();sf.close();hibernate.cfg.xml配置hibernate.hbm2ddl.auto属性取值: validate | update | create | create-drop在sessionfactory创建时,自动检查数据结构,或者将数据库schema(表)的DDL导出到数据库,使用create-drop时,在显式关闭sessionfactory时,将drop掉数据库schema.validate 加载hibernate时，验证创建数据库表结构create 每次加载hibernate，重新创建数据库表结构create-drop 加载hibernate时创建，退出是删除表结构update 加载hibernate自动更新数据库结构表名和类名不同的情况时,对表名进行配置1 在注解中import javax.persistence.Table;@Table(name=”TableName”)2 在XML文件中<hibernate-mapping package="com.model"><class name="Teacher" table="Teacher" >配置对应的table属性为相应的表名<id name="id" column="id"></id>…</class></hibernate-mapping>字段名和属性名相同,默认为对于annotation,如果什么注解都不写的话,相当于加了注解@Basic实体bean中所有的非static非transient的属性都可以被持久化, 除非你将其注解为@Transient.所有没有定义注解的属性等价于在其上面添加了@Basic注解. 通过@Basic注解可以声明属性的获取策略(fetch strategy)：对于XML文件中不用写column.字段名和属性名不同时Annotation:@column(name=”column_name”)加上相应的getXXX()方法上XML:column属性不需要persistence的字段import javax.persistence.Transient;@ Transient 意思是说这个属性是透明的,不进行持久化,存储的时候不存进去映射日期和时间类型,指定时间精度Annotation:import javax.persistence.Temporal;@Temporal(TemporalType.TIME)XML:指定type<class name="Teacher" table="Teacher" ><id name="id" column="id"></id><property name="name" type="time" />type=time或date</class>枚举类型的转换@Enumerated(EnumType.STRING)字段映射的位置推荐写在gexXXX方法上在程序中通过Hibernate 来保存java.sql.Clob 或者java.sql.Blob 实例时，必须包含两个步骤：1 在一个数据库事务中先保存一个空的Blob 或Clob 实例。

马士兵Spring学习笔记

课程内容1.面向接口（抽象）编程的概念与好处2.IOC/DI的概念与好处a)inversion of controlb)dependency injection3.AOP的概念与好处4.Spring简介5.Spring应用IOC/DI（重要）a)xmlb)annotation6.Spring应用AOP（重要）a)xmlb)annotation7.Struts2.1.6 + Spring2.5.6 + Hibernate3.3.2整合（重要）a)opensessionInviewfilter（记住，解决什么问题，怎么解决）8.Spring JDBC面向接口编程（面向抽象编程）1.场景：用户添加2.Spring_0100_AbstractOrientedProgramminga)不是AOP:Aspect Oriented Programming3.好处：灵活什么是IOC（DI），有什么好处1.把自己new的东西改为由容器提供a)初始化具体值b)装配2.好处：灵活装配Spring简介1.项目名称：Spring_0200_IOC_Introduction2.环境搭建a)只用IOCi.spring.jar , jarkata-commons/commons-loggin.jar3.IOC容器a)实例化具体beanb)动态装配4.AOP支持a)安全检查b)管理transactionSpring IOC配置与应用1.FAQ:不给提示：a)window – preferences – myeclipse – xml – xml catalogb)User Specified Entries – addi.Location:D:\share\0900_Spring\soft\spring-framework-2.5.6\dist\resources\sprin g-beans-2.5.xsdii.URI:file:///D:/share/0900_Spring/soft/spring-framework-2.5.6/dist/resource s/spring-beans-2.5.xsdiii.Key Type: Schema Locationiv.Key:/schema/beans/spring-beans-2.5.xsd2.注入类型a)Spring_0300_IOC_Injection_Typeb)setter（重要）c)构造方法（可以忘记）d)接口注入（可以忘记）3.id vs. namea)Spring_0400_IOC_Id_Nameb)name可以用特殊字符4.简单属性的注入a)Spring_0500_IOC_SimplePropertyb)<property name=… value=….>5.<bean 中的scope属性a)Spring_0600_IOC_Bean_Scopeb)singleton 单例c)proptotype 每次创建新的对象6.集合注入a)Spring_0700_IOC_Collectionsb)很少用，不重要！参考程序7.自动装配a)Spring_0800_IOC_AutoWireb)byNamec)byTyped)如果所有的bean都用同一种，可以使用beans的属性：default-autowire8.生命周期a)Spring_0900_IOC_Life_Cycleb)lazy-init (不重要)c)init-method destroy-methd 不要和prototype一起用（了解）9.Annotation第一步：a)修改xml文件，参考文档,在<context:annotation-config />，此句话会初始化AutowireAnnotationBeanPostProcessor，CommonAnnotationBeanPostProcessor，PersistenceAnnotationBeanPostProcessor，RequireAnnotationBeanPostProcessor。

java笔记马士兵版

java笔记马士兵版第一章基础语法1.程序执行过程2.java变量的分类3.java数据类型的划分4.数据类型所占的空间大小注意：数值范围数值转换数据类型之间的转化5.运算逻辑符的关系6.do..while 和while的区别执行语句和判断语句执行先后的问题7.break和continue的区别（代码分析）8.方法形式参数：在方法被调用时接收外外界输入的数据。

实参：调用方法时实际传给方法的数据。

返回值：方法执行完毕后返还给调用它的环境的数据。

返回值类型：事先约定的返回值的数据类型，如无返回值，则返回值类型为void。

注意：第二章面向对象1.对象和类的概念2.java与面向对象、类的定义3．Java面向对象的基本概念—引用Java语言中除基本类型之外的变量类型都称之为---引用类型。

Java中的对象通过引用对其经行操作4.构造方法1.当赋值完毕后，栈空间的_id 和_age 会被清除。

2.当没有写构造函数时，编译器会自动添加形如类名（）{} 的构造函数。

5.this关键字（代码分析）6.static关键字（代码、内存分析）注意：private static int sid=0; 存储在 data seg 中。

而其余的成员变量存储在stack中。

原因是 static关键字。

7.package和import的语句8.类的集成与权限控制9.方法的重写（代码分析）Super关键字：来引用基类的成分在cc.f（）语句中，先执行的是基类的Syso 然后是子类的Syso10.继承中的构造方法11.toString、equals 方法12.对象转型13.动态绑定和多态（代码分析）14.抽象类●用abstract修饰一个方法时，这个方法是抽象方法。

●用abstract修饰一个类时，这个类是抽象的类。

●含有抽象方法的类，必须声明为抽象类，抽象类必须被继承，抽象方法必须被重写。

●抽象类不能被实例化。

●抽象方法只需声明，而不需实例。

马士兵MCA高级互联网架构师学习笔记

马⼠兵MCA⾼级互联⽹架构师学习笔记```javapackage com.mashibing;public class MyCalculator implements Calculator {public int add(int i, int j) {int result = i + j;return result;}public int sub(int i, int j) {int result = i - j;return result;}public int mult(int i, int j) {int result = i * j;return result;}public int div(int i, int j) {int result = i / j;return result;}}```CalculatorProxy.java```javapackage com.mashibing;import ng.reflect.InvocationHandler;import ng.reflect.Method;import ng.reflect.Proxy;public class CalculatorProxy {public static Calculator getProxy(final Calculator calculator){ClassLoader loader = calculator.getClass().getClassLoader();Class<?>[] interfaces = calculator.getClass().getInterfaces();InvocationHandler h = new InvocationHandler() {public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Object result = null;try {result = method.invoke(calculator, args);} catch (Exception e) {} finally {}return result;}};Object proxy = Proxy.newProxyInstance(loader, interfaces, h);return (Calculator) proxy;}}``````javapackage com.mashibing;public class Test {public static void main(String[] args) {Calculator proxy = CalculatorProxy.getProxy(new MyCalculator()); proxy.add(1,1);System.out.println(proxy.getClass());}}```**动态代理的源码：**Proxy.java的newProxyInstance⽅法：```javapublic static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException{//判断InvocationHandler是否为空，若为空，抛出空指针异常Objects.requireNonNull(h);final Class<?>[] intfs = interfaces.clone();final SecurityManager sm = System.getSecurityManager();if (sm != null) {checkProxyAccess(Reflection.getCallerClass(), loader, intfs);}/** Look up or generate the designated proxy class.* ⽣成接⼝的代理类的字节码⽂件*/Class<?> cl = getProxyClass0(loader, intfs);* Invoke its constructor with the designated invocation handler.* 使⽤⾃定义的InvocationHandler作为参数，调⽤构造函数获取代理类对象实例*/try {if (sm != null) {checkNewProxyPermission(Reflection.getCallerClass(), cl);}//获取代理对象的构造⽅法final Constructor<?> cons = cl.getConstructor(constructorParams);final InvocationHandler ih = h;if (!Modifier.isPublic(cl.getModifiers())) {AccessController.doPrivileged(new PrivilegedAction<Void>() {public Void run() {cons.setAccessible(true);return null;}});}//⽣成代理类的实例并把InvocationHandlerImpl的实例传给构造⽅法return cons.newInstance(new Object[]{h});} catch (IllegalAccessException|InstantiationException e) {throw new InternalError(e.toString(), e);} catch (InvocationTargetException e) {Throwable t = e.getCause();if (t instanceof RuntimeException) {throw (RuntimeException) t;} else {throw new InternalError(t.toString(), t);}} catch (NoSuchMethodException e) {throw new InternalError(e.toString(), e);}}```getProxyClass0(ClassLoader loader,Class<?>... interfaces)```javaprivate static Class<?> getProxyClass0(ClassLoader loader,Class<?>... interfaces) {//限定代理的接⼝不能超过65535个if (interfaces.length > 65535) {throw new IllegalArgumentException("interface limit exceeded");}// If the proxy class defined by the given loader implementing// the given interfaces exists, this will simply return the cached copy;// otherwise, it will create the proxy class via the ProxyClassFactory// 如果缓存中已经存在相应接⼝的代理类，直接返回，否则，使⽤ProxyClassFactory创建代理类 return proxyClassCache.get(loader, interfaces);}* a cache of proxy classes*/private static final WeakCache<ClassLoader, Class<?>[], Class<?>>proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory()); ```。

Java相关课程系列笔记之十四Hibernate学习笔记-(28076)

Hibernate学习笔记Java相关课程系列笔记之十四笔记内容说明Hibernate（梁建全老师主讲，占笔记内容100%）；目录一、Hibernate的概述 (1)1.1 Hibernate框架的作用 (1)1.2 Hibernate访问数据库的优点 (1)1.3 JDBC访问数据库的缺点 (1)1.4 Hibernate的设计思想 (2)二、Hibernate的基本使用 (3)2.1 Hibernate的主要结构 (3)2.2 Hibernate主要的API (3)2.3 Hibernate使用步骤 (4)2.4 HQL语句（简要介绍） (15)三、数据映射类型 (16)3.1映射类型的作用 (16)3.2 type映射类型的两种写法 (16)四、Hibernate主键生成方式 (18)4.1五种生成方式 (18)五、Hibernate基本特性 (20)5.1对象持久性 (20)5.2处于持久状态的对象具有的特点 (20)5.3三种状态下的对象的转换 (21)5.4批量操作：注意及时清除缓存 (21)5.5案例：三种状态下的对象使用 (21)5.6一级缓存机制（默认开启） (23)5.7一级缓存的好处 (23)5.8管理一级缓存的方法 (24)5.9延迟加载机制 (26)5.10具有延迟加载机制的操作 (26)5.11常犯的错误 (26)5.12延迟加载的原理 (27)5.13 Session的get和load方法的区别 (28)5.14延迟加载的好处 (28)5.15案例：测试延迟加载 (29)5.16案例：重构NetCTOSS资费管理模块 (30)5.17 Java Web程序中如何用延迟加载操作（OpenSessionInView） (35)六、关联映射 (41)6.1一对多关系one-to-many (41)6.2多对一关系many-to-one (43)6.3多对多关联映射many-to-many (45)6.4关联操作（查询join fetch/级联cascade） (49)6.5继承关系映射 (57)七、Hibernate查询方法 (63)7.1 HQL查询 (63)7.2 HQL和SQL的相同点 (63)7.3 HQL和SQL的不同点 (63)7.4 HQL典型案例 (64)7.5 Criteria查询 (71)7.6 Native SQL原生SQL查询 (73)八、Hibernate高级特性 (75)8.1二级缓存 (75)8.2二级缓存开启方法及测试 (75)8.3二级缓存管理方法 (77)8.4二级缓存的使用环境 (78)8.5查询缓存 (78)8.6查询缓存开启方法及测试 (78)8.7查询缓存的使用环境 (79)九、Hibernate锁机制 (80)9.1悲观锁 (80)9.2悲观锁的实现原理 (80)9.3悲观锁使用步骤及测试 (80)9.4乐观锁 (83)9.5乐观锁的实现原理 (83)9.6乐观锁使用步骤及测试 (83)十、其他注意事项 (85)10.1源码服务器管理工具 (85)10.2利用MyEclipse根据数据表自动生成实体类、hbm.xml (85)10.3根据实体类和hbm.xml生成数据表 (88)10.4 Hibernate中分页查询使用join fatch的缺点 (88)10.5 Hibernate的子查询映射 (89)一、Hibernate的概述1.1 Hibernate框架的作用Hibernate框架是一个数据访问框架（也叫持久层框架，可将实体对象变成持久对象，详见第5章）。

Java相关课程系列笔记之十四Hibernate学习笔记

(价值3000元)Java自学之路—马士兵

Java自学之路-马士兵老师 2011年09月19日尚学堂java培训作者：马士兵老师JAVA自学之路一：学会选择为了就业，不少同学参加各种各样的培训。

决心做软件的，大多数人选的是java，或是.net，也有一些选择了手机、嵌入式、游戏、3G、测试等。

那么究竟应该选择什么方向呢？我的意见是，不要太过相信各种培训机构或是抢手文章的说法（包括我），当你要走向社会的时候，就不要再把自己当成学生，不要把自己的将来交给别人，学会运用自己的眼睛去观察，去了解这个世界吧。

每个培训机构都会宣传自己的好处，并不能说明大的趋势。

一些新闻文章很有可能是枪手写的，不必太过相信。

国外背景的教师和课程，未必适合你。

那么怎么才能确定自己将来的方向？如何才能从纷繁复杂、或真或假的数据世界中挖出一条路？我讲一个通过招聘网站的观察方法。

可以到各种招聘的网站上查询信息（可以到google上查询招聘的网站），例如：以及csdn的招聘频道等还有一个网站也不错，，综合了各大招聘网站的数据。

这些数据都是最真实不掺假的原始数据，你可以每隔一段时间搜索一次，一些规律就会被总结出来了。

比如说我在中搜索java，全国大概提供了3万个职位。

然后要多翻几页，这样不仅能够看清楚大概有多少是有效的职位，而且还可以看清楚用人单位最关心的技能是什么，这个很重要，决定着你将来要花多少时间和精力在特定的知识点上，比如说swing，搜了一下，全国只有700个左右的职位，仔细读了一下，也并非全是有效的职位，花太多时间和精力在这个上面就不值得了，当然自己感兴趣或者为了研究的话另当别论。

不过如果是为了快速的就业，把太多时间和精力花在很多职业生涯的前一、二年用不到的知识上就太可惜了。

同时，并非某一个行业的职位数目少，就不能当作一个方向进行选择，比如.NET，我搜索到的职位数是1.6万左右，比java少，是不是就选java了呢？不一定，因为java职位虽然多，但是可能竞争者可能也多，有些方向虽然职位数不多，但是和你竞争这些职位的人数量也少，不见得就不能选择。

马士兵高级架构师笔记

马士兵高级架构师笔记一、为啥要做这个笔记呢？咱就是说，马士兵老师的高级架构师课程那可老厉害了。

我听的时候就感觉脑子不够用，但又不想错过任何知识点，所以就开始做笔记啦。

这个笔记就像是我的小宝藏，里面全是架构师相关的干货。

每一个知识点都像是一颗小星星，我把它们一颗颗收集起来，就想攒成一个知识的银河系。

二、笔记都有啥内容呢？1. 架构的基础概念这部分就像是盖房子的地基一样重要。

它包括什么是架构，架构在软件开发中的意义，还有不同类型架构的特点。

比如说分层架构，就像蛋糕一样一层一层的，每一层都有它自己的功能，不能乱套。

我当时理解这个概念的时候，就想象自己是个蛋糕师傅，要把每层蛋糕都做得恰到好处。

2. 设计模式这里面有好多有趣的设计模式呢。

像单例模式，就好像整个世界只有一个超级英雄一样，在程序里就是只有一个实例。

还有工厂模式，就像是一个神奇的工厂，可以根据不同的需求生产出不同的对象。

我每次学到一种新的设计模式，就感觉自己又多了一种魔法技能。

3. 架构的性能优化这可是很关键的部分哦。

毕竟我们希望我们做出来的架构跑得又快又稳。

这里面包含了如何提高系统的响应速度，减少资源的占用等等。

比如说缓存的使用，就像我们的大脑会记住一些经常用到的东西一样，程序也可以把一些常用的数据缓存起来，下次再用的时候就可以直接拿出来，不用再重新计算了。

三、这个笔记对我有啥帮助呢？首先，在学习的时候它能让我更好地理解课程内容。

有时候老师讲得很快，我来不及消化，但是一看笔记就清楚多了。

其次，在做项目的时候，我可以把笔记里的知识运用到实际中。

比如说在设计项目架构的时候，我就可以参考笔记里的各种架构模式，选择最适合的那个。

最后，这个笔记也是我学习成长的一个记录，我可以看到自己从对架构一知半解到逐渐掌握的过程，就很有成就感呢。

反正这个马士兵高级架构师笔记对我来说超级重要，就像我的一个学习小助手，陪着我在架构师的学习道路上一路前行。