黑马程序员技术交流社区

标题: 【厦门JavaEE就业1期-每日总结】MVC和事务 [打印本页]

---

作者: 厦门校区    时间: 2018-6-9 16:31
标题: 【厦门JavaEE就业1期-每日总结】MVC和事务
同学们，今天主要内容是MVC和事务，代码量不大，更多是需要理解。

今日需要掌握的有：

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

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

---

作者: q55w66    时间: 2018-6-9 19:44
王清松
事务(针对数据库)
        概述
                逻辑上的一组操作(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说我只捏一个碗，你们就用一个碗吃把

---

作者: 咸鱼coder    时间: 2018-6-9 19:50
万冕

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

反射主要是获取字节码对象去调用执行方法:
先用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代码无关!!
开启事务,提交事务,回滚事务的连接对象一定要同一个对象!!!!

---

作者: 许大炮    时间: 2018-6-9 19:50
许剑鸿 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 ( )回滚事务

---

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

---

作者: 小故事    时间: 2018-6-9 20:08
谢洪彬:
今天又对反射进行了一次重温:
获取反射的三种方法
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对象为同一个才不会出现错误.

---

作者: 李志勇    时间: 2018-6-9 20:15
李志勇:
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");

---

作者: Nevermo    时间: 2018-6-9 20:21
许煜   每日总结
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 (隔离级别)
隔离级别设置越高级,性能越低,应该做合理的取舍.

---

作者: 磬辰    时间: 2018-6-9 20:25
林文辉

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;
        }

---

作者: 六道的骸6    时间: 2018-6-9 20:53
张裕
今天回顾了下反射的知识
反射是通过获取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模型层

---

作者: 1748341437    时间: 2018-6-9 21:19

2018/6/9  林瑋

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

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

---

作者: hpb199567    时间: 2018-6-9 21:21

何平波
生词: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三层结构是一群开发人员提出来的.

---

作者: 厦门陈强    时间: 2018-6-9 21:31
陈强
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,参数 )之外,还必须传入连接对象---放在第一个参数的位置!!!

---

作者: rkko    时间: 2018-6-9 21:32
杜石苇
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

---

作者: AsusCoder    时间: 2018-6-9 21:33
曾耀峰
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是个成熟的框架，暂时没有代替品。其他两层都有其他框架可以代替

---

作者: doudou0606    时间: 2018-6-9 21:35


施炎生
今日总结：
一．        重点：
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关键字相同也会报错。

---

作者: wpwing    时间: 2018-6-9 21:37
吴鹏
总结

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

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

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

---

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

---

作者: LittleSky    时间: 2018-6-9 21:49
常小天
今天我们首先回顾了反射的内容。反射可以获得一个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的方法中从线程中获得连接，因为每个用户的访问都会有一条专属的唯一的线程，所以能够保证整个事务中使用的是同一个连接。

---

作者: 5119    时间: 2018-6-9 21:50
游荣辉
总结
今天复习了一下反射,反射就是在运行状态中,都能够调用里面的方法,属性或者构造方法(包括私有的)
想要使用反射,第一步就必须要先获得到他的字节码对象,获得字节码对象的方式有三种
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里

---

作者: 13163997058    时间: 2018-6-9 21:52


王刘锁
从入门到精通,随着技术的革新动态页面开发模式越来越完善,无数前辈实验后得出结论就是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两种相对来说比较高性价比的级别

---

作者: 厦门黑马王子    时间: 2018-6-9 21:54
郑雪平

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

---

作者: Yanmo_    时间: 2018-6-9 21:54
颜琳琳
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.虚读

---

作者: 郑学馨    时间: 2018-6-9 21:55
郑学馨
什么是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

---

作者: Eclipse启动    时间: 2018-6-9 21:56
郑阳阳
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

---

作者: finfin12    时间: 2018-6-9 21:56
张育辉
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,你要传的参数

---

作者: 沅瞻    时间: 2018-6-9 21:58
詹源

内省:
?内省:用来获得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;

---

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

---

作者: sts    时间: 2018-6-9 21:59
苏海斌

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

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

---

作者: 名字被人注册了    时间: 2018-6-9 21:59
刘文峰
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                        :串行化的.不会发生隔离问题.效率最低

---

作者: 偏离X    时间: 2018-6-9 22:01
MVC 分为模型,视图,控制器,
模型层(Service,Dao ..)
视图层(HTML,JSP ...)
控制层(Servlet...)

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

---

作者: chenyelong    时间: 2018-6-9 22:01
陈叶隆
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);

---

作者: 望蜀    时间: 2018-6-9 22:05
邵倩

反射:操作类中的属性和方法
当我们不知道要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向下传递管理事务的方法
通过反射获得属性方法并让方法执行   

---

作者: 滴滴eclipse启动    时间: 2018-6-9 22:20
江某人:
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                        :串行化的.避免脏读，不可重复读，虚读的发生.

---

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

---

作者: COLDER    时间: 2018-6-9 23:33




[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);方法回滚事务

---

作者: 一梦    时间: 2018-6-9 23:37
陈世彪:
今天学习了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()

---

作者: 铁木啊童臂    时间: 2018-6-9 23:39
汪志阳:
今天首先再次学习的反射,反射可以让我们通过类的字节码文件获取类的对象,这样就可以更加方便的而且暴力的获取对象,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



---

作者: 张述明    时间: 2018-6-9 23:54
张述明
今天对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里面>

---

作者: 追风筝的人哇    时间: 2018-6-10 00:27
康元中

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

---

作者: 黄志彬    时间: 2018-6-10 01:44
        黄志彬
        反射
第一步获得代表这个类加载到内存的字节码文件的对象Class对象（）
推荐使用class的forname的静态方法获得 Class.forName("类的全路径");
class去操作构造方法，属性，方法

内省基于反射实现，主要用于操作JavaBean，通过内省 可以获取bean的getter/setter

beanutils导两个包 logging和beanutils

JDBC 中的事务管理
setAotuCommit();自动提交模式
commit提交
rollback回滚
如果有异常就rollback，没有异常就commit


        三层架构和MVC是不同时期的不同东西，它们毫无关系的，
        web层                业务层                持久层
        servlet JSP        javabean        JDBC
        Struts2                Spring                Hibernate
        SpringMVC                        MyBatis
        Struts1                                DBUtils
        WebWork                                JDBCTemplate


        MVC是Model(模型层)        主要负责出来业务逻辑以及数据库的交互
        View(视图层)                主要用于显示数据和提交数据
        Controller(控制器)        主要是用作捕获请求并控制请求转发

使用servlet+JSP+javabean开发目前市面上的大部分项目，企业级中SSH.SSM框架进行开发

---

作者: 李思贤126    时间: 2018-6-10 09:50
李思贤:反射

public  void run(){
                System.out.println("跑");
        }
private String SayHello(String name){
                return "hello"+name;
        }
通过反射得到Javabean中的方法(公有私有都可获得)
Class clazz = Class.forName("com.itheima.Domain.Account");
                Method method = clazz.getDeclaredMethod("run");
                method.setAccessible(true);
                method.invoke(clazz.newInstance());
               
                System.out.println("-------------");
               
                Method method2 = clazz.getDeclaredMethod("SayHello", String.class);
                method2.setAccessible(true);
                String s = (String) method2.invoke(clazz.newInstance(), "李思贤");
                System.out.println(s);
}




事物
事物:要么全部成功,要么全部失败.

转账案例:三种方式(1贾琏欲执释 2DBUtils 3本地线程(了解))详见项目Day0609
注意Double的转换
Double money = (Double.parseDouble(request.getParameter("money")));

---

作者: Do1    时间: 2018-6-10 10:24




MVC就是模型层 显示层 和控制层,模型层存放数据从控制层里面去拿,显示层显示给客户端

模型层主要通过javabean封装好数据,控制层Servlet去拿javabean的数据或者从文件中拿到数据,然后通过JSP显示层显示在客户端上

事务回滚主要掌握向下传递

---

作者: it小白001    时间: 2018-6-10 11:36
吴俊斌

mvc模式:
  M(模型层):处理数据库中数据的增删改查 Javabean service dao
  v(视图层):主要是负责显示 jsp,html,css,js等
  c(控制层):主要负责从视图读取数据,控制用户输入,并向模型层发送数据 servlet

事务:
  事务是对数据库的操作,由于多线程,会出现安全问题.我们操作的时候要保证要么
全部成功,要么全部失败.
   在java代码中,一般通过开启事务(setAutomatic),将自动提交改为手动提交
   把异常捕获,如果没出现异常,那么执行提交事务(commit).出现异常执行rollback
回滚事务
   
反射获得方法:
    1,先获得字节码对象,有三种方式.用的最多最灵活的是:
      Class.forName(包名加类名)
    2,创建对象
      如果构造public并且无参可以通过字节码对象.newInstance()
      如果是有参私有的构造,可以通过构造器,getDeclaredConstructor()
      在newInstance()

    3.获得方法
      私有的.通过字节码对象Class.forName("").getMethod(方法名, 参数)
      再调用.invoke(obj, args)

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2