王刘锁
从入门到精通,随着技术的革新动态页面开发模式越来越完善,无数前辈实验后得出结论就是MVC是很好用的一种开发模式,其实就是我们常用的JSP和Servlet加上JavaBean的开发模式,做了这么多的案例,大概也知道了它们的作用,JSP就是显示,Servlet是控制器,JavaBean是封装数据的实体类,那我们可以得知MVC呢也是架构格式,M是Model模型层就是JavaBean,V是View视图层也就是JspC那就是Controller控制层对应的就是控制器Servlet,那我们要把它和三层架构分开来,三层架构是由数据访问层(WEB层),业务逻辑层(业务层),页面层(客户端层)三层组成,两者是不同时期不同组织开发人提出的,MVC是一群开发者,三层架构是SUN公司的,它俩的区别是MVC的控制层和视图层合并成了三层架构的WEB层,而三层架构的业务层(javabean/Spring..)和持久层(JDBC/DBUtils..)相当于MVC的模型层.
暴力反射获取类的方法并执行:为了代码的灵活性但是降低性能,就是让任意一个类可以动态获取它的任意方法和属性:先获取类的class对象我们用着一种方法就好Class clazz = Class.forName(com.itheima.User);获取对象Object user = clazz.newInstance();暴力反射获取方法:Method method = clazz.getDeclaredMethod("方法名");取消权限:method.setAccessible(true);执行:method.invoke(user);
事务的四大特性:原子性-不可分割,一荣俱荣,一损俱损. 一致性-数据不可改变,隔离性-事务间互不相干,持久性-事务一旦提交或回滚数据就永久保存..事务的安全性问题:脏读:读到还没有提交事务的数据.不可重复读:相同的查询语句读到不一样的结果数据被更新,虚读/幻读:读到数据的时候被插入数据,导致读到的数据和本来的数据不一致,为了解决这些问题,学习了事务的隔离级别,级别从大到小是serializable:串行化的,事务排毒执行,完美的避开所有问题,虽然安全性高但是性能低,repeatable read:可重复读:避免脏读和不可重复读,在事务开启读取数据的时候不允许修改数据的事务,但是会发生虚读因为虚读是插入数据,Read committed:已提交读,只可以避免脏读,读取的是提交后的数据,有事务在更新数据时不能读取,最后是read uncommitted:未提交读.可以读到其它事务未提交的数据,安全性最低,性能最高,无法解决任何读问题,所以一般使用的是read committed 和repeatable read两种相对来说比较高性价比的级别

郑雪平

今天学习了两方面的内容，分别是反射和事务管理，这些都是之前有接触过的了，今天算是重温之前学的知识点。重点是学习使用反射如何获得类的构造方法和私有属性，也可以获取公有属性。MVC的模式可分为两种，第一种是JSP+javabean模式，它的优点是显示数据和封装处理数据都很方便，缺点是后期维护麻烦；第二种是jsp+servlet+javabean模式，jsp负责显示数据Javabean负责封装处理数据servlet则专门负责控制。
  第二部分是事物事务管理，事物就是逻辑上的一组操作，各个逻辑单元联成一体要么一起成功要么一起失败。对数据库进行事务管理的操作过程分为三步，1.启动事物；2.提交事物；3.回滚事物。目前学的是Mysql数据库，它默认是自提交事物的。事务管理的隔离级别分为四个等级：一.未提交读；二.已提交读；3.可重复读；4.串行化的。其中级别最低最容易发生安全性问题的是未提交读，级别最高的是串行化，它可以很好的避免安全性问题的发生。

颜琳琳
MVC设计模式中:M:模型层 v:视图层 c:控制层 于三层结构的区别在于:MVC是一群WEB开发人员,EE的三层结构是SUM公司提出.
  事务: MYSQL的事务管理有两种方式:(MYSQL数据库事务默认是自动提交的.Oracle数据库事务默认是不自动提交.)
1.手动开启事务
start transaction; -- 开启事务
commit/rollback(提交/回滚);
2.设置一个自动提交参数
show variables like '%commit%'; -- 查看与commit相关参数.
set autocommit = 0; -- 将autocommit参数设置为OFF.
事务的隔离性:
1.脏读 2.不可重复读  3.虚读

郑学馨
什么是java中的反射机制:
比喻:给你一具尸体,你通过解刨该尸体可以了解里面的一些构造,还可以获得里面的所有器官,
反射:就是通过一个类字节码文件,可以获得字节码文件里面的所有构造方法和定义的常量变量等,

反射的功能:
        1:可以构造任意一个类的对象
        2:可以获得任意一个类的所有成员变量(包括私有的)和成员方法
        3:可以调用任意一个对象的方法

反射的前提:获得我们所要的获得的类的字节码对象
        获得方法:
                方法一:(类名).class;(常用)
                方法二:Class.forName(全类名);(常用)
                方法三:对象名.getClass;

注意:在8大基本数据类型的包装类中,都有一个常量:TYPE,用于返回该包装类对应基本类的字节码对象.因此，Integer.TYPE

== int.class，但是注意，Integer和int是不同的数据类型

反射方法:

关于对象:
        1:创建对象(newinstance())
                Class clazz=Class.forName("全类名");
                object obj=clazz.newInstance();
        (*使用newInstance()创建对象时,类中必须要无参构造存在)
关于类中的方法:
        2:获得类中的方法(getMethods())
                Method[] methods=clazz.getMethods();
        (*获得类中的所有方法,私有的方法除外,返回一个方法数组)
        3:获取所有的方法(getDeclaredMethods())
                Method[] methods=clazz.getDeclaredMethods();
        (*获得类中的所有方法,返回一个方法数组)
        4:获得类中的方法(getMethod("方法名"))
                Method method=clazz.getMethod("方法名");
        (*获得类中指定方法名的方法,私有的方法除外,返回一个方法)
        5:获取所有的方法(getDeclaredMethod("方法名"))
                Method method=clazz.getDeclaredMethod("方法名");
        (*获得类中指定方法名的方法,返回一个方法对象)
关于方法的调用:
        6:invoke(obj,methodname,args);
        (invoke:调用,通过invoke可以调用类中的任意方法)
        OBJ:类的对象
        methodname:要调用的方法
        args:调用方法要传入的参数
        7:method.invoke(obj,args)
        (与上面的注解方式一致,表达方式不一样而已)
关于构造方法:
        8:获取类中所有的构造方法:getConstructors()
        9:获取类中的指定参数的构造方法:getConstructor(string.class,integer.class)
关于利用字段获取:
        获取指定Field名=: name
        获取指定对象字段'name'的Field的值=： ABC
        设置指定对象字段'name'的Field的值=: changwen2
        获取指定私有字段名=: age

郑阳阳
MVC设计模式，分清这三者各自负责什么，并注意MVC与三层架构的区别（很重要）:
M:model 模型层 Dao Secvice JavaBean
V:view  视图层 JSP
C:controller 控制层 Servlet

三层架构:
WEB层 业务层 持久层

EE的三层结构和MVC是由不同时期的人或组织提出的不同解决方案,
MVC是由一群WEB开发人员提出的,EE三层结构由SUN公司提出.
两者并不冲突,可以同时存在

Mysql和Oracle默认的隔离级别,事务隔离问题有哪些，隔离级别有哪些？
Read Uncommitted 虚读,不可重复读,脏读都有可能发生
Read Committed         虚读,不可重复读可能发生
Repeatable Read 虚读
Serializable 什么读都不会发生

Mysql默认级别为Repeatable Read
Oracle默认级别为Read Committed

张育辉
1:什么是反射
                        java反射机制是在运行状态中,可以获取对象的成员(成员方法和成员属性),可以调用成员方法;
                2:获取字节码对象三种方式
                        1:可以通过对象.getClass();
                        2:类名.class;
                        3:Class.forName("全类名");
                3:通过字节码对象获取构造对象
                        1:getConstructors() 获取一个类中所有的公共的构造方法,返回Constructors数组
                        2:getConstructor((可以有参数,不传就是空参数)) 根据参数获取指定的公共的构造方法, 返回Constructor对象
                        3:getDeclaredConstructor((可以有参数,不传就是空参数))获取私有的
                                       
                4:通过字节码对象直接获取对象
                        获取对象,newInstance()空参newInstance()
                        Object obj =        class.newInstance()
                       
                5:获取类中成员变量
                        1:getField(); public修饰的
                        2:getDeclardField() 获取所有的成员属性包括私有
                                需要调用setAccessible(true)方法,告诉JVM我要暴力访问,让jvm不检查权限
                                实例:反射private属性执行流程
                                1. 获取person类字节码对象   Class cl = Class.forName("com.itheima.demo.Person");
                                2. 获取person对象                        Object person = cl.newInstance();
                                3. 通过getDeclaredField方法获取私有字段   Field f = cl.getDeclaredField("age");比如你要获取age私有属性
                                4. 通过setAccessible让jvm不检查权限    f.setAccessible(true);
                                5. 通过set方法设置对象为具体的值    f.set(person, 24);
                               
                6:获取成员方法
               
                        1:getMethod() 获取public修饰的成员方法 ,返回类型 Method对象,参数1是访问的方法名,参数2,是方法需要传的类型.class
                                                        调用方法  对象名.invoke() 参数1,对象名 参数2,你要传的参数
                                                       
                        2:getDeclaredMethod() 获取所有修饰的成员方法,格式:同上
                                                        需要调用 setAccessible(true)让jvm不检查权限
                                                        执行方法  对象名.invoke()        参数1,对象名 参数2,你要传的参数

詹源

内省:
?内省:用来获得JavaBean的属性及属性的get或set方法.
JavaBean:就是一个满足了特定格式的Java类:
* 需要提供无参数的构造方法:
* 属性私有
* 对私有的属性提供public的get/set方法.
?内省的代码:
        public void demo1() throws Exception{
                // 获得了Bean的信息
                BeanInfo beanInfo = Introspector.getBeanInfo(User.class);
                // 获得Bean的属性描述了
                PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
                for(PropertyDescriptor pd:pds){
                        System.out.println(pd.getName());
                        /*pd.getReadMethod(); // 获得get方法
                        pd.getWriteMethod();// 获得set方法.
*/                }
        }

设置自动提交参数
show variables like '%commit%';
set autocommit=0;   关闭自动提交
conn.setAtutoCommit(false);不自动提交

通过事务管理控制转账:
Service完成操作
DAO是方法?
事务管理添加在Service层(业务层).必须由同一个对象管理的事务才是同一个事务
Service调用DAO层
开启事务→↓

提交事务→同一个conn  ← dao (不要在DAO里conn.close)否则会影响到事务层操作,释放资源在事务层进行

回滚事务→↑

事务管理:要么全部成功要么全部不成功.

事务管理
方式一:在Service创建Connection传递给DAO.称为向下传递
这种向下传递有代码侵入性.

方式二:获取Connection后,绑定到一个当前线程中.重新写一个新的JDBCUtils工具类
        在DAO中获得连接的话,可以从当前线程中获取.每个用户都使用独立线程
.        每次访问,都会创建新的conn;

吴利君
今天学了很多，首先是复习了反射，通过类名拿到类的方法属性，其中有共有的获取和私有的暴力获取，这些知识之前有学过，复习！
然后是java中的内省模式，这个了解就好，然后是数据库的事务管理，这个主要有三个事务，开启事务提交事务和回滚事务，这个今天讲了两种方式，分别是线程方式和向下传递，其中线程方式hibernate这个框架使用的，DBUTils是向下同步！
然后是MVC模式和EE得三层结构，这两者是不同时期的不同思想，我们现在的程序都兼容，比如三层模式，Servlet层，service层以及dao层，其中Servlet是控制层，jsp是视图层，其他的是模型层。

苏海斌

MVC
M指的是模型层,主要是JavaBean
V是视图层,即JSP部分
C是控制层,也就是Servlet
三者加起来也就是MVC的设计模式;
而MVC与三层架构其实是不同时期不同组织或个人提出的JSP开发模式
虽然代码比较少,但主要还是结合代码去理解,说是说不清的

事务的隔离目前主要是理解就好,
事务如果不考虑隔离性,会引发一些安全性问题;
例如脏读(一个事务读到另一个事务还未提交的数据),
不可重复读(一个事务读到另一个事务已提交的update的数据,导致在当前的事务中多次查询结果不一致),
虚读(一个事务读到另一个事务已提交的insert的数据,导致在当前的事务中多次查询结果不一致)等;统称为类读;
隔离级别:
read uncommitted:未提交读.   脏读,不可重复读,虚读都可能发生
read committed:已提交读.  避免脏读.  但不可重复读和虚读有可能发生
repeatable read:可重复读. 避免脏读,不可重复读.  但虚读有可能发生
serializable:串行化的.  避免脏读,不可重复读,虚读的发生

刘文峰
MVC是由web开发人员提出的一种设计模式,由模型层,视图层,控制层组成:
M: model  模型层  封装处理数据(用javabean实现)
V: View  视图层  将数据以视图的形式响应给客户端(用jsp实现)
C : Controller  控制层  接收客户端发来的请求,将请求分配给模型层(用servlet实现);
客户端发送请求和数据,控制层接收并传递给模型层,模型层处理完成后由视图层响应回客户端.
Javaee的三层架构由sun公司提出,分为web层,业务层,持久层
Web层 : servlet+jsp  接收和响应
业务层 : javabean  处理业务
持久层 : JDBC  操作数据
三层架构和MVC作用是一样的,web层相当于MVC的控制层和试图层,业务层,持久层相当于MVC的模型层;

事务:逻辑上的一组操作,要么全部成功,要么全部失败
事务有四个特性:隔离性,持久性,原子性,一致性
事务的隔离问题:多个事务同时开启时,可能会引发隔离问题,分为三种:
脏读:一个事务读到另一个事务未提交的数据;
不可重复读:一个事务读到另一个事务已经提交的update的数据,
虚读:一个事物读到另一个事务已经提交得insert的数据
事务的隔离级别:解决事务的隔离问题,分为四个
read uncommitted                :未提交读.脏读，不可重复读，虚读都可能发生.效率最高
read committed                :已提交读.避免脏读.但是不可重复读和虚读有可能发生.
repeatable read                :可重复读.避免脏读,不可重复读.但是虚读有可能发生.
serializable                        :串行化的.不会发生隔离问题.效率最低

MVC 分为模型,视图,控制器,
模型层(Service,Dao ..)
视图层(HTML,JSP ...)
控制层(Servlet...)

事务的级别分为
第1级别:read-uncommitted:该级别引发的问题是——脏读()：读取到了未提交的数据的执行结果
第2级别：Read Committed:这种隔离级别出现的问题是——不可重复读：不可重复读意味着我们在同一个事务中执行完全相同的select语句时可能看到不一样的结果。
第3级别：Repeatable Read(可重读):此级别可能出现的问题——幻读(Phantom Read)：当用户读取某一范围的数据行时，另一个事务又在该范围内插入了新行，当用户再读取该范围的数据行时，会发现有新的“幻影” 行
第4级别：Serializable(可串行化):在这个级别，可能导致大量的超时现象和锁竞争
MySql中默认的是第三级别的事务隔离:Repeatable Read(可重读)

陈叶隆
1. 反射:(通过反射获得Person类中的求和方法,并调用)
Class clazz = Class.forName("com.reflect.Person");
                Method m1 = clazz.getDeclaredMethod("sum",int.class,int.class,int.class);
                m1.setAccessible(true);
                int invoke = (int) m1.invoke(clazz.newInstance(), 2,3,4);
2. 事务:
事务的管理的API(connection对象):
i) void  setAutoCommit (blooean autoCommit ):将此连接的自动提交模式设置为给定状态
ii) void  commit( ):        使所有上一次提交/回滚后进行的更改成为持久更改，并释放此Connection对 象当前持有的所有数据库锁
iii) void  rollback ( ):        取消在当前事物中进行的所有更改，并释放此Connection 对象当前持有的所有数据库锁
servlet:
                //Post方式接收的参数有中文,需要设置编码
                request.setCharacterEncoding("utf-8");
                //从request中接收的参数都是String类型的,需要转换类型
String s = request.getParameter("money");
                double money = Double.parseDouble(s);
service:
conn=JDBCUtils.getConnection();
                        conn.setAutoCommit(false);
                        dao1.outMoney(conn,from,money);
                        dao1.inMoney(conn,to,money);
                        DbUtils.commitAndCloseQuietly(conn);

邵倩

反射:操作类中的属性和方法
当我们不知道要new谁的对象时,就可以使用反射得到对象 例如web.xml底层
反射的执行过程: java文件---编译成class文件---JVM中有一个类的加载器ClassLoader---将class文件加载到虚拟机中(内存中),那么有一个Class对象(代表class文件加载到内存后所形成的一个对象)


使用反射的第一步 :  获得class文件加载到内存形成的字节码文件的对象
三种方式:
          // 一种:通过类名.class
          Class clazz1 = Person.class;
          // 二种:通过类的实例对象.getClass()方法获得.
          Person person = new Person();
          Class clazz2 = person.getClass();
          // 三种:使用Class的forName的静态方法获得.(推荐使用这种)
          Class clazz3 = Class.forName("com.itheima.demo3.reflect.Person");

通过反射操作其构造方法的一个例子
DBUtils: Person person=queryRunner.query(sql,new BeanHandler<Person>(Person.class));

Java中的内省技术  基于反射   只能获得类(JavaBean)中属性和属性的set get方法
JavaBean: 满足了特定格式的Java类
其中需要提供私有属性
提供私有属性的public的set/get方法
提供无参构造方法

事务管理
事务指的是逻辑上的一组操作,组成这组操作的各个逻辑单元要么一起成功要么一起失败
MYSQL的事务管理(了解)
MYSQL的事务管理有两种方式(MYSQL数据库事务默认自动提交.Orecle数据库事务默认不自动提交)
1.手动开启事务
2.设置一个自动提交参数

JDBC中的事务管理(掌握)
JDBC的事务管理的三个API:
setAutoCommit()
commit()
rollback()

案例 转账
创建一个页面
导入JDBC相关的jar包和工具类
创建包结构
提交到Servlet---Service---DAO
页面跳转/打印

DBUtils实现事务管理
没有事务管理:
有事务管理:


MVC设计模式属于web开发 并不专属于JavaEE

EE开发的三层结构  WEB层(Servlet JSP) 业务层(JavaBean) 持久层(JDBC)  可以开发目前市面上的大部分项目
但是目前企业中使用SSH,SSM框架进行开发

今日必须掌握:
DBUtils向下传递管理事务的方法
通过反射获得属性方法并让方法执行   

江某人:
MVC:
M(model)模型层:负责在数据库中存取数据,处理数据逻辑  javabean service dao
V(view)视图层:负责数据显示 jsp
C(controller)控制层:负责从视图读取数据,控制用户输入,并向模型层发送数据 servlet
MVC与EE开发的三层结构之间没有必然联系 是不同时期不同的人提出的开发解决方案 谈不上有区别
Mysql和Oracle默认的隔离级别:
setAutoCommit（boolean）设置是否自动提交、commit（）提交的方法、rollBack（）回滚的方法。
设置事务的隔离级别:
read uncommitted                :未提交读.脏读，不可重复读，虚读都可能发生.
read committed                :已提交读.避免脏读.但是不可重复读和虚读有可能发生.
repeatable read                :可重复读.避免脏读,不可重复读.但是虚读有可能发生.
serializable                        :串行化的.避免脏读，不可重复读，虚读的发生.

16weisong
今天学习了反射,内省和事务管理,反射之前java部分已经学过的了,内省是基于反射的,beanUtils就是使用内省,事务部分需要掌握管理事务的第一种方式;向下传递连接.DBUtils就是使用这种方式来管理事务

[MVC And Commit]

1.MVC是什么?
MVC(Model View Controller)是一种设计模式,由JSP+Servlet+JavaBean组成.
Model模型层:JavaBean,作用是封装数据和处理数据.
View显示层:JSP,作用是将数据显示到浏览器上,也就是客户端
Controller控制层:Servlet,作用从浏览器request获取数据,向浏览器response响应数据,将要实现的功能交给业务层service处理.

2.什么是反射?
Java中的反射指得是在运行状态中,对于任意一个类都可以知道其所有属性和方法,都可以调用其任意的方法.也就是可以实现动态获取和
动态调用对象的方法.原本调用对象方法的形式是通过创建类对象,然后通过对象来调用方法,而反射是另外的方式,通过字节码对象来获取
字节码对象,然后通过字节码对象来获取类中的字段或调用类中的方法.

3.字节码对象的获取方式?
(1).对象名.getClass():这种方式是在已经存在对象后使用的方法.
(2).类名.class
*(3).Class.forName("全类名"):一般获取字节码对象都使用该方法.

4.如何使用反射获取公共/私有的成员变量,公共/私有的成员方法?
(1).获取字节码对象:class clazz = Class.forName("全类名");
(2).创建类对象:Object obj = clazz.newInstance();
(3).获取公共/私有的成员变量:Field f = clazz.getField("字段名")/getDeclaredField("字段名");
获取公共/私有的成员方法:clazz.getMethod("方法名")/getDeclaredMethod("方法名");
(4).如果是获取私有成员变量或成员方法需要让JVM不检查权限:setAccessible(true).

5.事务是什么?
事务指的是逻辑上的一组操作,组成这组操作的各个逻辑单元要么一起成功,要么一起失败,也就是使用事务可以确保两件事情在交互的过程中
具有安全性.比如说转账案例或者是存档案例.事务是用来针对数据库进行管理的,mySQL数据库的事务默认自动提交,Oracle数据库的事务默认
不自动提交.

6.事务管理的主要步骤?
(1).创建事务:关闭自动提交事务,setAutoCommit (false);
(2).开启事务:当代码无异常执行完毕才会开启事务,commit();
(3).回滚:当异常发生时,可以进行回滚,rollback();

7.转账案例使用DBUtils实现连接向下传递的思路?
(1).通过JDBCUtils获取连接池
(2).关闭自动提交事务
(3).编写扣款和收款的Dao方法
(4).使用DBUtils.commitAndCloseQuietly(conn);方法开启事务
(5).使用DbUtils.rollbackAndCloseQuietly(conn);方法回滚事务

陈世彪:
今天学习了MVC和事务
MVC模式:
M(model)模型层:负责在数据库中存取数据,处理数据逻辑
可以看作javabean
V(view)视图层:负责数据显示
可以看作jsp
C(controller)控制层:负责从视图读取数据,控制用户输入,并向模型层发送数据
servlet,分布任务给下面
JSP + Servlet + JavaBean 称为MVC的设计模式.
三层架构(3-tier architecture) 通常意义上的三层架构就是将整个业务应用划分为：表现层（UI）、业务逻辑层（BLL）、数据访问层（DAL）。区分层次的目的即为了“高内聚，低耦合”的思想。
事务的四种隔离级别
1 read uncommitted 最低级别,全部错误读法都可能发生
2 read committed 避免脏读     MySQL默认隔离级别
3 repeatable read 避免脏读 不可重复读 Oracle默认隔离级别
serializable   全部避免(包括虚读)
java中操作事物的方法

设置事物是否自动提交
conn.setAutoCommit(false);
设置是否提交
conn.commit();
回滚事务
conn.rollback()

汪志阳:
今天首先再次学习的反射,反射可以让我们通过类的字节码文件获取类的对象,这样就可以更加方便的而且暴力的获取对象,Class clazz = Class.forName("com.itheima.demo.Person");着重掌握通过类的全路径获取对象的方法
获取完字节码文件后,就可以通过.newInstance()实例化对象;.getDeclaredMethod()获取方法的地址值,再通过.invoke的方法得到对象中的方法.对于一些类中的private的成员变量,方法我们需要设置它的权限在进行获取.
内省技术:这是一个基于反射的,用来获取javaBean的属性及属性的get或set方法.
事务:逻辑上的一组操作,组成这组操作的各个逻辑单元要么一起成功,要么一起失败.
JDBC的事务管理:主要掌握三个API,setAutoCommit:设置事务的开放状态,commit()提交事务,并释放该事务
rollback()回滚事务,主要可以再事务中出现错误是回滚,避免前后事件执行情况的不一致,事务主要有四种特性:
1.原子性：强调事务的不可分割.2.一致性：强调的是事务的执行的前后，数据的完整性要保持一致.
3.隔离性：一个事务的执行不应该受到其他事务的干扰.4.持久性：事务一旦结束(提交/回滚)数据就持久保持到了数据库.
然后就是利用事务去完成转账功能的案例:在案例中了解到了线程,线程和对象一样,每一个mvc的执行必然携带着线程,我们创建了线程
的工具类,每一个数据的执行都会形成一个线程.这样案例让我们对MVC开发有了更进一步的认识.
MVC:主要是Servlet+JSP+javaBean,jsp主要是显示页面,Servlet是一个控制层,连接jsp和javabean,javaBean则是一个主要代码的实现
三层框架是:客户端层,web层和业务层,客户端层主要是java,html,css,js;web层主要有servlet+jsp组成,业务层主要是EJB



张述明
今天对mvc有了进一步的理解 ,回顾了一下反射,
重点掌握反射获取对象私有的方法

无参
1.        获得字节码对象
2.        Clazz.getDecarlareMethod()获得类中的方法
3.        让方法执行,使用 method.invoke(clazz.newIstance())
有参
Clazz.getDecarlareMethod(“方法名” ,(参数类型)String.Class)
String  s=(String )method.invoke(clazz.newIstance() ,”method””凤姐”);



Java中的内省技术
内省:获得javaBean的属性以及get 和set 方法

JavaBean是一个满足特定格式的Java类






事务管理  是数据库的
事务是逻辑上的一组操作,组成这组操作的各个单元要么一起成功,要么一起失败.

Mysql的事务管理有两种方式(mysql数据库自动提交,Oracle不自动提交)
1.        手动开启---start transaxtion—开始事务---commit/rollback;
2.        设置一个自动提交参数  show variable like ‘% commit%’—查看与Commit相关信息
Setantocommit=0;--将autocommit参数设置为空
JDBC中的事务管理
SetAutocoomit(boolean)  设置不自动开启(false)

Commit()    提交事务

Rollaback()    回滚<写在catch里面>

康元中

MVC设计模式
M : model模型层用来封装数据 和 处理数据就是个javaBean
V:view 视图层 就是JSP
C:Controller 控制层 想当于Servlet(指挥官)接收请求然后将事情交给M层做
EE开发的三层结构
  客户端
  WEB层  ervlet JSP
  业务层 JavaBean
  持久层 JDB
EE开发三层结构和MVC是不同时期提出来的开发解决方案没有必然联系

反射:
反射第一步是获得calss文件加载到内存后形成字节码文件的对象 class对象
calass对象便可以获取构造,成员变量和成员方法包括私有放方法
重点掌握通过反射获取私有方法;
1 Class.forName()获取字节码对象
2 获取类的对象clazz.newInstance()
3 获取私有方法        clazz.getDeclaredMethod ("方法名","方法参数的class")
4 解除权限mthod对象.setAccessible(true)
5 method对象.invoke(对象名,"方法的参数")

事务：逻辑上的一组操作，在这组操作中的各个逻辑单元要么一起成功，要么一起失败。
DBC中的事务管理：
1.setAutoCommit()  参数为布尔类型，用于设定是否自动提交事务
2.comment()  提交事务
3.rollback   事务回滚
注意:操作数据库事务: 回滚的是数据库中的数据和java代码没关系
**两种方式实现事务管理(转账案例)
1 向下传递 :就是在服务层获取连接 将Connection对象传递到Dao中保证了使用的是
            同一个连接
2 线程绑定: 也是在服务层上获取连接,但是先写个工具类在工具类中完成线程的绑定和从线程中拿取连接
              添加事务等操作 这样也保证了Dao中的连接也是一致的效果
            
beanUtils 使用包commoms-logging-jar 和commons.beanutils,jar