同学们，今天主要内容是MVC和事务，代码量不大，更多是需要理解。

今日需要掌握的有：

• 首先要掌握MVC设计模式，分清这三者各自负责什么，并注意MVC与三层架构的区别（很重要）
• 事务，我们首先记住Mysql和Oracle默认的隔离级别。待我们学了框架之后，事务是框架帮我们操作，所以目前对大家的要求就是理解，能陈述并理解事务隔离问题有哪些，隔离级别有哪些？
  

请同学们按照如上要求，总结今日所学。

王清松
事务(针对数据库)
        概述
                逻辑上的一组操作(DML)，组成这组操作的各个逻辑单元，要么全部成功，要么全部失败
        使用
                开启事务:start transaction
                关闭事务
                        提交事务:commit
                        回滚事务:rollback
        特性
                原子性
                        逻辑单元不可分割
                一致性
                        事务执行前后，数据完整性保持一致
                隔离性
                        事务执行不应该受到数据库其他事务的干扰
                        安全性
                                脏读：一个事务读到另一个事务未提交的数据，导致查询数据不一致
                                不可重复读：一个事务读到了另一个事务已经提交的update数据，导致多次查询结果不一致
                                虚读：一个事务读到了另一个事务已经提交的insert数据，导致多次查询结果不一致
                        隔离级别
                                read uncommitted
                                read committed
                                        避免脏读
                                repeatable read(默认)
                                        避免脏读，不可重复读
                                serializable(最安全)
                                        效率很低，避免脏读，不可重复读，虚读
                        指令
                                设置隔离级别
                                        set session transaction isolation level 隔离级别
                                查看隔离级别
                                        select @@tx_isolation;
                持久性
                        事务一旦结束，数据就持久化到数据库中

绑定线程：
每个用户访问服务器，服务器都会为其开辟线程（服务器送给每个人一个包袱）
用户来到Service，Service创建了一个conn，绑定到线程上（Service给了你一个碗，你把它装入了包中）
用户来到Dao，直接用线程上的conn执行相关操作（来到Dao后，用户说，我自己带了碗，不用你的，然后dao就拿起用户提供的碗装狗粮喂他）

向下传递：
用户1访问服务器，服务器都为其开辟线程（服务器送给用户1一个包袱）
用户1来到Service，Service创建了一个conn，并传递给Dao
（Service根据你的编号，给你弄了一个碗，但是不送你，而是编号后，丢给Dao，说等下会有个编号为1的人，到时候拿这个碗装狗粮给他吃）
用户1来到Dao，用传递进来的conn可以操作（来到Dao后，用户说，我编号是1，
Dao就取出了编号1的碗，装狗粮喂用户1）

直接在dao中静态初始化一个conn：
用户1来到服务器，服务器啥也没做（无）
用户1来到Service，Service啥也没做（无）
用户1来到Dao，Dao第一次被访问，被加载，就创建了一个conn
(dao看见人来了，就自己做了个碗，装狗粮喂用户一)

如果这时候用户2，用户3也来了，不好意思，Dao说我只捏一个碗，你们就用一个碗吃把

万冕

今天算是对之前所学过的事务进一步加深一点点

反射主要是获取字节码对象去调用执行方法:
先用Class.forname获取到字节码对象,然后去调用getDeclared(只要出现这个就是获取私有)Method("传入方法名"),返回
一个方法对象,用方法对象去调用setAccessible(true)去把权限设置为true, 再用方法对象.invoke(字节码对象)


EE三层结构与MVC的区别

MVC的Servlet是在C控制层(Controller),而JSP是在V视图层(View)
EE三层结构的Servlet和JSP是合在一起的存在于WEB层(表现层)

EE:

搭建成型的积木(表现层){
        设计该怎样去搭建(业务逻辑层){
                取积木搭建(数据访问层){
                        一块一块的积木(操作数据库)
                        }
                }
        }

MVC:

M(model)模型层:是用来封装数据,处理数据.   javaBean
V(View)视图层:就是JSP,等M层封装处理好数据后,再显示到页面上   jsp
C(Contrller)控制层:请求过来后,处理请求,然后把事情交给M层做    Servlet

标记事务易混点:
*****************************
只控制数据库里的操作,和java代码无关!!
开启事务,提交事务,回滚事务的连接对象一定要同一个对象!!!!

许剑鸿 webDay19

MVC模式:
M(model)模型层:负责在数据库中存取数据,处理数据逻辑  javabean service dao
V(view)视图层:负责数据显示 jsp
C(controller)控制层:负责从视图读取数据,控制用户输入,并向模型层发送数据 servlet

MVC与EE开发的三层结构之间没有必然联系 是不同时期不同的人提出的开发解决方案 谈不上有区别


反射:通过获取字节码对象可以创建对象可以获取构造方法,成员变量,成员方法(包括私有);
重点掌握通过反射调用方法.
1首先获取字节码对象 Class.forName("全类名") / 类名.class/对象.getClass();
2获取method对象  .getDeclaredMethod("方法名","数据类型.class");
3method对象.setAssessible越过权限
4通过method对象调用invoke("对象名","参数")


事务:(MYSQL数据库事务默认是自动提交的.Oracle数据库事务默认是不自动提交)
事务的管理的API(connection对象):
1setAutoCommit (blooean autoCommit )设置连接的自动提交方式(是与否)
2commit( )提交事务
3rollback ( )回滚事务

柯威龙
今天又加深了对反射的印象,主要学习使用字节码对象去调用方法和成员.使用forname来获取字节码.
获取到字节码后类的加载器会将class文件加载到内存.变成class对象.
事务的话首先都是开启事务,提交事务,回滚事务.今天主要学习的是JDBC事务.事务的话也分为自动提
交和手动提交JDBC事务主要是使用Connection对象所控制的.而且事务的话主要是加在业务层上.
还学习了使用DBUtlis来完成事务的操作DB事务的话在工具类里面获取连接,当业务层,控制层和Dao里面使用的是同一个连接.
还学习了多线程来完成转账.但是从头到尾我都没听懂.只知道是使用本地线程.

谢洪彬:
今天又对反射进行了一次重温:
获取反射的三种方法
1.通过类名.class获取
2.通过调用对象调用getclass()
3.通过Class对象调用forName(全类名)来获取  (推荐使用)
通过反射我们可以获取该类的构造方法,成员变量,成员方法
构造方法:
空参构造--通过获取到的class对象调用newInstance()
有参构造--通过获取到的class对象调用getConstructor(参数类型.class .....)
成员方法:
非私有:通过获取到的class对象调用getField(“参数名”)
私有:通过获取到的class对象调用getDeclaredField(“参数名”)
成员方法:
非私有:通过获取到的class对象调用getMethod(“方法名”)
私有:通过获取到的class对象调用getDeclaredMethod(“方法名”)
注:当获取所有的私有的变量或方法是需要调用setAccessible(true)参数传一个true来开启访问权限
还有获取所有的变量和方法,就是在方法名后面多了一个s,获取到的数据也变成了对应的数组.
事务:一组逻辑上的操作,组成这组逻辑上的操作要么一起成功,要么一起失败
在JAVA中使用Connection来进行事务的管理操作,期中操作事务的方法有三个
1.setCommit()  -- 设置手动开起或关闭提交事务的,事务默认状态为true
2.Commie()                --提交事务的操作
3.Rollback                --回滚事务

今天进行了一个案例的转账,有两种方式进行
1.使用DButils的方式
commitAndCloseQuietly() -- 提交事务并归还连接
rollbackAndCloseQuietly() -- 回滚事务并归还连接
2.使用ThreadLocal线程的方式
相当于key和value的形式,key就是当前线程,value就是你存进去的泛型为Connection连接;
案例的重点在于连接对象的一致性,在使用对象进行开启事务,提交事务,和回滚事务的时候只有Connection对象为同一个才不会出现错误.

李志勇:
JSP的开发模式:
JSP + Servlet + JavaBean 称为MVC的设计模式.
MVC:
M:Model:模型层
V:View:视图层
C:Controller:控制层       
MYSQL的事务管理有两种方式:(MYSQL数据库事务默认是自动提交的.Oracle数据库事务默认是不自动提交.)
1.手动开启事务
        start transaction; -- 开启事务
        多条sql;
        commit/rollback;

2.设置一个自动提交参数
        show variables like '%commit%'; -- 查看与commit相关参数.
        set autocommit = 0; -- 将autocommit参数设置为OFF.
?JDBC的事务的管理的API:
        setAutoCommit(false)
        commit()
        rollback();
重新复习了反射  
        获取字节码对象  常用 Class clazz = Class.forName(传入全路径);
               
通过字节码对象获取方法(无参)        Method method = clazz.getDeclaredMethod("run");
忽视私有                        method.setAccessible(true);
调用方法                        method.invoke(clazz.newInstance());
通过字节码对象获取方法(无参)        Method method2 =clazz.getDeclaredMethod"run",String.class);
调用方法        String invoke = (String) method2.invokeclazz.newInstance),"xiaoxiao");

许煜   每日总结
Jsp设计模式:MVC: Model 模型层 ,View 视图层 ,Controller 控制层
Model-->JavaBean   View-->Jsp   Controller-->servlet
View:jsp主要负责网站在浏览器端的的显示效果的处理,如果将整个web系统比作一个人,jsp负责的view就如同一个人的外表一般.
Controller:servlet主要负责网页数据和后台数据库数据之间的交互及处理,同时还负责页面跳转等,如同一个人的大脑指挥一个人的各种行动
Model:JavaBean负责为servlet提供各种工具,负责封装数据,提供各种各样的方法处理各种事务,以供servlet调用.如同一个人的身体及手脚,负责接收大脑的各种差遣.
JavaEE三层结构 web层        业务层      持久层
              Jsp+servlet      JavaBean     JDBC
框架          Struts         Spring       Hibernate
               SpringMVC                 MyBatis
事务
事务的四种隔离级别
1 read uncommitted 最低级别,全部错误读法都可能发生
2 read committed 避免脏读     MySQL默认隔离级别
3 repeatable read 避免脏读 不可重复读 Oracle默认隔离级别
4 serializable   全部避免(包括虚读)
脏读 :一个事务读取到另一个事务还有提交结束的数据
不可重复读:一个事务读取到另一个事务已经提交的数据,导致多次查询结果不一样
虚读:一个数据读取到另一个事务已经insert的数据,导致在当前事务中的多次查询结果不一样.
Mysql设置隔离级别指令
set session transaction isolation (隔离级别)
隔离级别设置越高级,性能越低,应该做合理的取舍.

林文辉

MVC设计模式：JSP+Servlet+JavaBean

JAVA中的内省技术：用来获取JavaBean中的get和set方法。主要是通过反射，
反射在工具类中使用特别广泛，通过反射能使工具类的使用范围更加广泛，
提升通用性。

事务：逻辑上的一组操作，在这组操作中的各个逻辑单元要么一起成功，要么一起
失败。
比如同时往多张表添加数据或删除数据，如果其中有一个发生错误，就全部回滚。

MySQL的事务管理有两种：
1.手动开启事务   start transaction  -----  开启事务
2.set autocommit =0;  将自动提交的参数设置为off；

JDBC中的事务管理：
1.setAutoCommit()  参数为布尔类型，用于设定是否自动提交事务
2.comment()        提交事务
3.rollback                事务回滚

两种方式实现事务的提交
1.向下传递
public void save(Order order) {
               
                Connection conn = null;
                try {
                        conn=JDBCUtils.getConnection();
                        //开启事务
                        conn.setAutoCommit(false);
                        //保存订单
                        OrderDao orderDao = (OrderDao) BeanFactory.getBean("OrderDao");
                        orderDao.saveOrder(conn,order);
                        //保存订单项
                        for(OrderItems orderItems:order.getList()) {
                                orderDao.saveOrderItems(conn,orderItems);
                        }
                        //提交事务
                        DbUtils.commitAndCloseQuietly(conn);
                }catch(Exception e) {
                        e.printStackTrace();
                        DbUtils.rollbackAndCloseQuietly(conn);
2.线程绑定
public Integer deleteByCid(String delId) throws Exception {
                Integer delNums=null;
                try {
                                JDBCUtils2.beginTransaction();
                                CategoryDao categoryDao =(CategoryDao) BeanFactory.getBean("CategoryDao");
                               
                                delNums=categoryDao.delByCid(delId);
                                JDBCUtils2.commitTransaction();
                               
                }catch(Exception e) {
                        e.printStackTrace();
                        JDBCUtils2.rollBackTransaction();
                }
                return delNums;
        }

张裕
今天回顾了下反射的知识
反射是通过获取JVM内存中所存储的class对象 来实现对该类的操作 可以获取该类的所有成员 方法
获取类的字节码对象
1 类名.class       
2 类的对象.getClass()        
3 Class.forName("类的全路径") 一般使用这种
操作步骤
获取字节码对象→构造函数对象→类对象→获取属性对象→为所欲为

内省
用来获取JavaBean中的属性和get,set方法
JavaBean:满足特定格式的java类
        1 提供无参数的构造方法
        2 私有的成员变量
        3 提供get set方法

通过创建Introspector对象 来获得类的PropertyDescriptors属性描述器
可以获取到类的get set方法 来进行数据的操作

事务
逻辑上的一组操作 一起成功或者一起失败(例如转账)

JDBC中的事务管理
        1 setAutoCommit() 设置事务是否自动提交
        2 commit() 手动提交事务
        3 rollback() 回滚事务

ThreadLocal本地线程(连接Connection)
        1 创建线程对象 设置泛型
        2 get函数获取线程中的对象
        3 set函数设置线程中的对象

事务操作的两种方式
        1 通过向下传递Connection对象来进行事务的开启 提交 回滚
                但是代码的侵入性太强 不符合开发理念
        2 另外写一个工具类 创建线程存取对象 通过方法来获取线程中的对象来进行事务的操作
                每个用户有用一个独立的线程 彼此之间不冲突

事务的读写问题
        脏读:一个事务读到另一个事务还没有提交的数据
        不可重复读        :一个事务读到了另一个事务已经提交的update的数据,导致在当前的事务中多次查询结果不一致
        虚读/幻读        :一个事务读到另一个事务已经提交的insert的数据,导致在当前的事务中多次的查询结果不一致

解决方法 可以设置事务的隔离级别来毕业读写问题的发生 隔离级别越高 处理速度越慢

EE开发的三层结构
        客户端
        WEB层        Servlet JSP
        业务层        JavaBean
        持久层        JDBC
               
和MVC的关系
        WEB层的Servle相当于C控制层
        WEB层的JSP相当于V视图层
        业务层和持久层相当于M模型层

2018/6/9  林瑋

今天的重點就三個，MVC,反射还有事务.

什么是MVC设计模式?就是jsp,Servlet,javaBean加在一起就是MVC设计模式了,它全称是Model View Controller.Model是模型层主要由JavaBean组成,View是试图层就是JSP了,还有一个控制层Controller则是由Servlet组成了.我们现在写的页面就都是MVC了;
再就是反射了,反射的话之前是有学过的今天就当是复习了一遍,反射呢是他是通过字节码对象来获取参数的,他可以获取公有参数及私有参数,方法都是不同的私有的要去除private才能获取参数,公有的则不用.而今天的重心在获取方法这一块.
还有就是事务了,事务在WEB刚开始几天也有学,但是今天除了复习了一遍,还学习了事务的几个更简便的用法,加上之前的总共三个方式.这三个方式都是针对避免脏读,不可重复读及虚读来写的.然后来完成转账案例,熟练的完成并理解这个案例,事务这个知识点,也就算是掌握了.

何平波
生词:reflect  反射
getDeclardField():获取私有的属性
getDeclardConstructor():获取私有的构造方法
getDeclardMethod():获取私有的方法
newInstance():new一个实例对象
解除私有构造,属性限制
setAccessible(true),默然为false

Introspector类.
INfo 信息
MVC与事务
一.反射
什么是反射呢?
有一个.java文件,被jdk编译成.class文件,加载到内存,那么反射就是将这些class文件通过3种方法获得字节码对象.
第一种:通过类名  第二种:通过类的实例对象.getClass()方法获取  第三种:使用Class的forName()的静态方法获得
反射的目的,是为了类操作某个类的属性或方法

二.内省
概念:用来获得JB的属性的get或set方法
可以直接将javabean封装在一个BeanUtils中
BeanUtils.populate
导包:beanUtils.jar   loggin.jar

三.事务
概述:逻辑上的一组操作,组成这组操作的各个逻辑单元要么一起成功,要么一起失败
事务的3个功能  setAutoCommit() 设置提交或者是不提交
                Commit()提交事务
                rollback() 回滚事务
总结:
结合今天的转账案例,梳理一下自己对事务的理解.
事务就是修改数据库数据的java代码中,如果出现了代码程序错误或者是某些漏洞时,能让数据库的数据不会造成丢失,(简单理解就是如果事务有异常,
就回滚事务还未提交前的状态)
依靠着事务回滚,开启事务,执行事务这3个功能,能避免数据丢失.
原本想着靠着Beanhendel或者是Arrayhendel也可以实现对转账数据的修改,但事务的功能需要jdbc的Connetion核心类的支持,
所以事务的3个功能还需要jdbc的原生代码或者是Dbutils工具类来实现.
DbUtils.commitAndCloseQuietly(conn);提交事务并关闭
DbUtils.rollbackAndCloseQuietly(conn);回滚事务并关闭

MVC和EE三层架构
什么是MVC呢?
MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，
将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。MVC被独特的发展起来用于映射传统的输入、处理和输出功能在一个逻辑

的图形化用户界面的结构中。
比如这几天的将Servlet,ServletService,ServletDao,JavaBean类分离在不同的包下,就是一种典型的MVC模式
Servlet(controller)网页解析的代码,ServletService一些衍生的业务层,ServletDao(model)执行对数据库的操作,JavaBean封装数据库数据,JSP(view).
这也是一种典型的MVC分层,这样有助于管理复杂的应用程序.

EE三层结构
WEB层(Servlet-JSP)-业务层(JavaBean)-持久层(JDBC)
MVC和EE三层架构的区别
这两者并没有什么区别,只是随着时间的发展,mvc和ee三层结构是一群开发人员提出来的.

陈强
MVC&事务的一天
今天的内容主要分为两部分---反射的回顾和事务的处理
首先是反射的回顾
-反射的目的就是为了操作某个类的属性或者方法
-首先都要获取其字节码对象,有三种方式获得
        -对象.getclass
        -类名.class
        -Class.forName + 全类名
然后可以获取到构造方法,属性,成员方法,这里面大致可以分为public修饰和private修饰两种,
被public修饰的直接用getConstructor\getField\getMethod即可获得,
而被private修饰的,就要用到对应的Declared的方法才能获取到私有的成员,并且获取之后必须设置权限---setAccessible为true时才可以被执行.
主要就是获取方法并执行,---invoke---method.invoke( clazz.newInstance( ) , 参数.class )
第二部分就是事务的管理
-事务就是指逻辑上的一组操作,组成这组操作的各个逻辑单元要么一起成功,要么一起失败.
-事务的API就是开启事务( SetAccessible ( false ) ) \提交事务 ( commit ) \回滚事务 ( rollback )
-我们进行事务的处理的时候,要将事务加再业务层,就是service中,因为事务必须要保证同一个连接对象.
-重点使用DbUTils来处理事务,这里有个需要注意的就是使用queryRunner的update或者query方法的时候,除了正常传入的参数 ( sql语句,BeanHandeler,参数 )之外,还必须传入连接对象---放在第一个参数的位置!!!

杜石苇
MVC设计模型：
定义：MVC 设计模型是一种使用 Model View Controller（ 模型-视图-控制器）设计创建 Web 应用程序的模式。

　　由上主谓宾可以很容易看出，mvc模型是一种用来写web应用程序的样式，也就是说只能写web不能写其它？

既然使用了 Model View Controller（ 模型-视图-控制器）



Model（模型）：是应用程序中用于处理应用程序数据逻辑的部分。
　　　　通常模型对象负责在数据库中存取数据。


View（视图）：是应用程序中处理数据显示的部分。
　　　　通常视图是依据模型数据创建的。


Controller（控制器）：是应用程序中处理用户交互的部分。
　　　　通常控制器负责从视图读取数据，控制用户输入，并向模型发送数据。

1.MVC框架，它强制性的使应用程序输入、处理和输出分开。使用MVC应用程序被分成三个核心部件：模型、视图、控制器。它们各自处理自己的任务。
　　由上可知，要使用MVC框架，则一定要遵守该框架的规则，它有它的强制性所在。一看就知道，它所使用的三个核心部件其实都是来自MVC模型。
　　只不过在框架中让他们彼此更加独立了去处理各自的任务而已。
2.最典型的MVC就是JSP + servlet + javabean的模式。
3. 视图：视图是用户看到并与之交互的界面。视图主要有元素HTML ，JSP，XML/XSL,等一些标识语言和Web services。
模型：模型表示数据和业务规则。

控制器：控制器接受用户的输入并调用模型和视图去完成用户的需求，所以当单击Web页面中的超链接和发送HTML表单时，控制器本身不输出任何东西和做任何处理。它只是接收请求并决定调用哪个模型构件去处理请求，然后再确定用哪个视图来显示返回的数据。   比如 servlet

设置事务的隔离级别:
* read uncommitted                :未提交读.脏读，不可重复读，虚读都可能发生.
* read committed                :已提交读.避免脏读.但是不可重复读和虚读有可能发生.
* repeatable read                :可重复读.避免脏读,不可重复读.但是虚读有可能发生.
* serializable                        :串行化的.避免脏读，不可重复读，虚读的发生.

***** MYSQL隔离级别：repeatable read  Oracle隔离级别:read committed

曾耀峰
web08_反射&JDBC事务&MVC总结
一、反射
   今天再次学习了反射。反射的作用是通过字节码文件.class文件可以获得这个java类的所有成员信息。总体来说，反射很重要，除了可以用来制作工具类，在后面框架的学习中也大量运用了反射。详细总结一下反射的运行机制。
  1.反射的运行过程:当一个java类A.java运行时，首先被翻译成虚拟机JVM能识别的A.class字节码文件，类的加载器ClassLoder将class文件加载到虚拟机中，反射通过获得A.class字节码文件的对象Class对象,来获得原来java类的所有信息
  2.反射在获得字节码文件对象后，将这个文件A.class分为三部分:
Constructor对象:存放构造函数的部分
Filed对象：存放成员变量
Method对象:存放成员方法
  3.获取Class对象，掌握两个方法:
  1)Class clazz1 = Person.class;类名.class
  2)Class clazz2 = Class.forName("com.web.bean.Person")；
  4.实例化对象:
   Class clazz = Class.forName("com.web.reflect.Person");
   Person person = (Person) clazz.newInstance()  
  5.获取有参构造函数,并实例化对象:
  Constructor c = clazz.getConstructor(String.class,Integer.class);
  Person p = (Person) c.newInstance("张森",38);
  6.获取私有方法，解除权限，执行方法:
Method method1 = clazz.getDeclaredMethod("run",String.class);
method1.setAccessible(true);
method1.invoke(clazz.newInstance());
  7.Tomcat通过web.xml中的<servlet-class>反射获取该Servlet的过程:
Class clazz = Class.forName("com.web.servlet.TestServlet");
Servlet myservlet =(Servlet) clazz.newInstance();
Method service = clazz.getDeclaredMethod("service", HttpServletRequest.class,HttpServletResponse.class);
service.invoke(myservlet,new HttpServletRequest(){"接口很多不写",new HttpServletResponse(){"接口很多不写"}
   最后还有一个内省技术，是获取类的所有get方法，来做成javaBean。了解即可

二、JDBC中的事务。
  事务回滚是用来控制当JAVA代码发生异常时，在此之前操作的数据库中的数据能够返回到原来的状态，防止数据更新丢失。事务的回滚机制是用来针对数据库操作的数据，和java代码没有关系。也就是说，事务回滚的数据库中的数据，不是Java中的变量。
   事务是在数据库连接对象Connection conn对象中。在整个事务的操作中，Connection必须是一个单例对象，也就是同一对象。Connection对象提供了操作事务的三个方法setAutoCommit(false)手动开启事务，commit()提交事务，rollback()回滚事务。在启动事务和提交事务这个区间存放数据操作方法，在发生异常才可以使数据库返回事务开启前的状态。rollback()回滚事务要放在catch()代码块里面。
  今天的案例是使用事务通过MVC设计模式来实现转账功能。首先在前端创建汇款页面money.jsp，表单提交的信息汇款人from,收款人to,转账金额money。使用post方法提交到MoneyServlet中。先用post方式处理中文编码问题。在服务端中，Servlet->service->dao三个层次的操作中。事务代码应该存放在service类中,service类使用加钱inMoney()方法，和出钱outMoney()方法。这两个方法执行的更新数据代码一模一样，只要在DAO类中创建一个updateMoney方法 。两个方法同时调用这个方法就可以，其中取钱outMoney()方法的money参数*（-1）表示减钱
   在事务操作中，针对connection对象在事务操作中是相同的对象，有三种方法实现一个事务工具类:
1.connction向下传递模式:从servlet->service->dao，依次作为参数传递。
2.在本地线程ThreadLocal依次存取同一个connection对象。默认情况下，服务器为每个访问的客户创建不同的线程，ThreadLocal表示该用户的线程。在开启事务，提交事务，回滚事务三个过程中，用一次conn对象 conn = TL.get()，存一次conn对象TL.set(conn)。这样使connction是同一个对象。
   conn依次传递的代码具有侵入性，不好扩展。
3.使用Dbutils工具类的方法CommitAndQuitely() 安静地提交 CommiAndQuitely() 安静地回滚。这两个方法在内部都把异常处理掉，也是比较好用的工具。

三、EE三层结构和MVC设计模式(了解)
  1.javaEE三层结构分别是WEB层，业务层，持久层。采用MVC模式设计。WEB层Servlet+JSP，业务层存放Bean实体类:商品类，用户订单类这些业务类。持久层作为数据的操作和持久化保存。
  2.使用Servlet+JSP+JavaBean+JDBC可以开发大部分常见的网站项目，只是现在少用，在企业大都使用SSH(Struct2,Spring,Hiberate)三大框架分别对象EE的三层结构进行开发。其中业务层的Spring是个成熟的框架，暂时没有代替品。其他两层都有其他框架可以代替

施炎生
今日总结：
一．        重点：
1.反射：通过反射获得方法，并且执行
2.事务：本地线程，向下传递（使用DBUTils）
二:复习了反射
1.        获取字节码对象有三种方式,主要使用Class.forName(“全类名”)。
2.        反射构建对象
(1)        获得Class对象：Class clazz = Class.forName("com.itheima_01.Student");
(2)        通过构造对象获得实例化对象
无参数时可使用Object obj=clazz.newInstance()；
有参数只能使用Contructor c=clazz.getConstructor(String.class)， Object obj=c.newInstance(“李四”);
3.        反射操作私有成员变量
(1)        获取该类中需要操作的字段（成员变量）
Field f=clazz.getDeclaredField(“name”);
f.setAccessible(true);//设置反射时取消java的访问检查，暴力访问
f.set(student,”李四”);
f.get(student);
4.反射获得成员方法
（1）无参无返回值
Method m=clazz.getMethod(“getName”);
m.invoke(student);
（2）有参有返回值
Method m=clazz.getMethod(“getName”，String.class);
Object obj=m.invoke(student,“李四”);
（3）获取私有成员方法同上面第三点，使用暴力反射。
三、复习了BeanUtils
(1)用来给对象中的属性赋值(了解)BeanUtils.setProperty(student, "name", "zhangsan");
(2)用来获取对象中的属性(了解)String name = BeanUtils.getProperty(student, "name");
(3)用来给对象中的属性赋值(掌握)BeanUtils.populate(student,map);
以后在Servlet中可以使用这种方法来封装数据
四、事务
1.事务指的是逻辑上的一组操作,组成这组操作的各个逻辑单元要么一起成功,要么一起失败.
2. coon.setAutoCommit(false)关闭自动提交功能
  coon.commit 提交
  coon.rollback回滚
注意：回滚的是数据库中的数据，和其它的java代码无关，比如int i=1；--- i=5;----system.out.println(i)输出的仍然是5，不会回滚为1.
五、使用dbutils处理事务:
在service里面生成coon连接再作为参数传给Dao
coon.setAutoCommit(false);
DbUtils.commitAndCloseQuietly(coon);
DbUtils.rollbackAndCloseQuietly(coon);

六、敲代码BUG
1.在JSP中使用post的方式提交，而在Servlet中post方法内忘记调用doGet方法了。
2. String sql="update user set money=money-? where name=?";
写成了String sql="update table user money=money-? where name=?";
3.注意创建表时数据库名，表名和mysql关键字相同也会报错。

吴鹏
总结

MVC设计模式不是由SUN公司提出来的,它是由外部推荐进来,是针对类与类,对象与对象关系的一种模式;
MVC设计模式即为Model--View--Controller(模型层--视图层--控制层),其中模型层负责实体,视图层
负责显示实体,控制层用来控制各个对象的数据处理;
三层架构由SUN公司提出的一个EE的设计思想;是一个软件的设计思想,
三层架构分别是:界面层--业务逻辑层--数据访问层;
界面层与用户的交互,业务逻辑层负责处理数据,数据访问层专门用来和数据库进行交互;

------------------------------------------------------
事务的隔离:
隔离级别一共有4种,由低到高分别是:
Read uncommitted 读未提交
Read committed     读已提交
Repeatable read     可重复读
Serializable             串行化

事务中会发生的隔离问题有:
脏读:一个事务读取到另一个事务未提交的数据,解决办法是将权限设置为Read committed;
不可重复读:在一个事务中,使用相同的sql语句读取到不同的内容,原因是有一个交叉的事务提交导致或者该库被多个对象操作,在本事务提交前被做了其它的操作;解决办法是将权限设置为Repeatable read;
幻读:读取到了不应该读取的数据,在一个事务操作后,另一个事务在该数据库中加入新行导致;解决办法是将权限设置为Serializable;

侯玉林
1.什么是MVC?
        JSP + Servlet + JavaBean 称为MVC的设计模式.
       
2.MVC分别都指那三层?
        M:Model:模型层- JavaBean,Dao,Service
        V:View:视图层 - JSP
        C:Controller:控制层 - Servlet
       
3.MVC用来干什么?
        MVC是一种开发代码的思想,实现高内聚,低耦合.

常小天
今天我们首先回顾了反射的内容。反射可以获得一个java类的构造与成员，包括私有的。反射的第一步就是获得这个类的class对象，获得class对象的方法有三种，我们着重掌握第三种：Class.forName(全类名)。获得class对象后，通过class对象可以获得这个类的任意一个属性或方法。获得属性我们可以使用“class对象.getDeclaredField("属性名称")”方法。这种方法可以获得包括私有成员的所有成员变量。获得方法我们可以使用“class对象.getDeclaredMethod("方法名称"，参数类型的class对象…)”方法，该方法也是可以获得包括私有方法在内的所有方法。这里要注意的是我们获得的属性和方法都是对象，无法直接获得他们的内容，我们还需要通过这些对象调用相应的方法才能获得其内容。要获得成员变量的值我们可以使用“属性对象.get(所属类的实例)”方法，要执行成员方法我们要使用“方法对象.invoke(所属类的实例, 参数…)”。当然，如果我们使用的是私有的成员的话，一定不要忘记设置取消权限，使用“成员对象.setAccessible(true)”方法来完成这一步。
接下来我们再次学习了事务的相关内容。事务指的是逻辑上的一组操作，组成这组操作的各个逻辑单元要么一起成功，要么一起失败。在mysql中我们通过手动开启事务和提交事务的方式来管理事务。今天我们学习的是在JDBC中管理事务。实现这一操作我们要用的主要方法有三个：setAutoCommit（boolean）设置是否自动提交、commit（）提交的方法、rollBack（）回滚的方法。在实际操作中我们将事务添加在业务层service中。这是因为我们需要用事务来管理的多个操作都是在service的一个方法中的，只有在这种情况下我们才能设置事务来实现这些操作的同时成功和同时失败。在之前的学习中我们已经了解到在事务中我们要使用同一个连接来操控事务，所以我们需要将原本在DAO中的获得连接的步骤移至service中，根据DAO获取连接方式的不同我们将管理事务的方式分为了两种。一种是以向下传递的方式来保证DAO的不同方法获得同一个连接，这也是DBUtils管理事务时采取的方式。这种方式是在service中获得连接，将连接以参数的方式传递给DAO的方法来使用。这里在DBUtils的使用中有一点与以前不同。就是创建QueryRunner对象时使用无参构造而非以前的有参构造，而在调用update和query方法时使用带有Connection参数的方法而非以前不带Connection参数的方法。另一种是绑定线程的方式来实现事务管理的，Hibernate框架采用的就是这种方式。这种方法也是在service中获得连接，将连接绑定进当前线程（使用ThreadLocal的方法），再在DAO的方法中从线程中获得连接，因为每个用户的访问都会有一条专属的唯一的线程，所以能够保证整个事务中使用的是同一个连接。

游荣辉
总结
今天复习了一下反射,反射就是在运行状态中,都能够调用里面的方法,属性或者构造方法(包括私有的)
想要使用反射,第一步就必须要先获得到他的字节码对象,获得字节码对象的方式有三种
1.对象名.getClass
2.类名.Class
3.Class.forName(全路径);
第二步.拿着字节码对象调用getDeclaredMethod(方法名,有参数要加上参数属性的.class对象)方法,返回一个Method的对象
第三步.拿着Method对象调用setAccessible(boolean)方法,关闭私有权限.
第四步.Method对于像调用invike()来执行方法
还复习了事务,他也有三个方法
1.void setAutoCommit()  开启事务                        加在开头
2.Void commit                         提交事务                加在tay的最后       
3.Void rollback                         回滚事务                加在catch里