Mysql修改本地root密码

1、在DOS窗口下输入net stop mysql5 或 net stop mysql

2、开一个DOS窗口,这个需要切换到mysql的bin目录。
一般在bin目录里面创建一个批处理1.bat,内容是cmd.exe运行一下即可就切换到当前目录,然后输入

mysqld-nt --skip-grant-tables; 

 

mysqld --skip-grant-tables;

 

不要关闭窗口

3、再开一个DOS窗口,mysql -u root

4、输入:

use mysql
update user set password=password("new_pass") where user="root";
flush privileges;
exit

 

ipv4和ipv6访问控制列表

ACL(Access Control List,访问控制列表)分为基本和扩展(高级),

规则是逐条匹配的,默认有一条规则是deny any any。

把下面三台路由器变成个人电脑,并设置默认网关:

conf t
no ip routing
ip defaut-gateway 192.168.1.1

只允许192.168.1.2能够ping通1.1.1.1的基本ACL:

access-list 1 permit host 192.168.1.2
int f0/0
ip access-group 1 in

允许任何计算机能ping通192.168.1.1的扩展ACL:

access-list 100 permit icmp any 192.168.1.1 0.0.0.0 echo
int f0/0
ip access-group 100 in

查看access-list 100:

ip access-list extended 100
do sh ip access-lists
permit ip host 192.168.1.1 host 1.1.1.1

 

对欧洲人的一些看法

英国

说起欧洲,我第一个想起的大概是英国。英国人喜欢喝酒,很多人下班和同事去酒吧喝,不去酒吧就回家一定会喝上一小口。

什么威士忌啊,金酒啊。威士忌主要分为单一麦芽威士忌和调和型威士忌。单一麦芽威士忌主要是麦卡伦,格阑费迪,阿德贝哥,欧肯特轩等。调和型威士忌比如尊尼获加,芝华士,百龄坛等。

金酒的话主要是伦敦干金酒。说几个常见的品牌,像Beefeater,Tanqueray,Bombay,Hendrick’s等。

葡萄酒一般是待在家里喝,很少在外面喝,什么红葡萄酒、白葡萄酒、桃红酒、起泡酒。在英剧《摩斯探长前传》里雪莉酒出现的较多,那是在60年代,不知道现在他们喜不喜欢喝雪莉酒。

除了酒,映像最深的大概就是英国人爱论出身,论血统,信天赋,信阶级之分,这点我有点反感。可能是英国的历史遗留下来的问题。《浴血黑帮》里Shelby家族Tommy Shelby在伦敦混的风生水起,他老丈人也嫌弃他,毕竟是伯明翰黑帮出身。

德国

德国大学免费啊,没足够的资金去美国英国留学的人可以考虑去德国,但首先你需要会德国,去外面兼职听课都需要德语呢。拿到学位再交上两年税就能获得长期居住权,移民需要住8年。

法国

我觉得法国教育中对于记笔记(prise de note)能力的培养还是非常实用的。我曾经质疑过,为什么百分之80的法国人都能把公立大学的课程相对完整的记下来,事实上,这种记笔记的能力,是法国学生从初中至高中就开始一直训练的,关于记笔记也有非常翔实的方法论课程。然而这一点,在国内的教育里是空白的。

待更新。

 

清明回家有感

狗日的,差点就错过了回去的火车了,以后要么提前1个小时要么打车。信了这狗日室友的邪,半个小时怎么够。

回去看了一下老人家们,个个身体都不行了,得多回去看看他们,我在长大,他们在变老啊。

以前想回去都是想着出去花天酒地,搓麻将,这次不知道怎么了就想着多陪陪家人。那些酒肉朋友就少联系吧,努力学习,加油。

匆匆守望 消逝的南柯一梦

记得很久之前读过一篇小说,如题,至今这篇小说我映像深刻,每次身边有人离开的时候大概我就会想到文中的最后一句话:那些人来了又走,就像从来没来过。

白落梅的《林微因传》里说,每个人来到世上,都是匆匆过客,有些人与之邂逅,转身忘记;有些人与之擦肩,必然回首。所有相遇和回眸都是缘分,当你爱上了某个背影,贪恋某个眼神,意味着你已心系一段情缘。只是缘深缘浅,任谁都无从把握,聚散无由,我们都要以平常心相待。

回首这些年,来来往往确实蛮多人,初中,高中毕业各奔东西,有的人去工作了,有的人失去联系,有人留着电话扣扣号却没有联系。过得日子久了,春去秋来,花开花谢,你会不会发现,你错过了美好的青春,辜负了那些女人?

再想想当下的浑浑噩噩,当下的无所事事,当下的猪狗不如,这些是必然还是偶然?

日剧推荐

感觉日剧比国产剧更走心,推荐几部看过的日剧,不知道算不算自愈系,但剧里总有一个瞬间会让你潸然泪下吧。

《追忆潸然》

因为一个陌生人钱包里的信,在东京某搬家公司打工的乡下青年曾田练不远万里驱车来到北海道,并将人生黯淡的女孩林田音带回了东京。
三男三女,六个有着共通之处的年轻人,寻找他们的梦想、依靠以及多年后回忆起来一定会让他们潸然泪下的恋情…

《逃避虽可耻但有用》

25岁的森山实栗,单身一人,研究生毕业却没有找到正式工作,只能做合同工,随后又被解雇,正处在无业状态,无人问津,居无定所,饱尝生活的辛酸。实栗的父亲实在看不下去,作主让她到35岁的单身程序员津崎平匡家帮忙做家事。

《掟上今日子的备忘录》

还是gakki的剧,不幸的青年隐馆厄介经常被卷入各种事件,而且总被当成犯人,为了自我保护他不得不雇用侦探,从而认识了“忘却侦探”掟上今日子。

《深夜食堂》第一到四季

我有美食和酒,说出你的故事吧!!!该剧讲述发生在一个小餐馆的故事,这里的菜单只有猪肉酱汤套餐一种,但是老板可以根据客人的要求利用现有食材做出各种料理,而且他还会和客人一起带出一个个充满人情味的故事。

Hibernate 事务管理和缓存机制

一、Hibernate事务管理

1 什么是事务管理

事务(Transaction)是工作中的基本逻辑单位,可以用于确保数据库能够被正确修改,避免数据只修改了一部分而导致数据不完整,或者在修改时受到用户干扰。作为一名软件设计师,必须了解事务并合理利用,以确保数据库保存正确、完整的数据。数据库向用户提供保存当前程序状态的方法,叫事务提交(commit);当事务执行过程中,使数据库忽略当前的状态并回到前面保存的状态的方法叫事务回滚(rollback)。

2 事务的特性

原子性(Atomicity)
一致性(Consistency)
隔离性(Isolation)
持久性(Durability)
简称ACID。下面对这4个特性分别进行说明。
原子性:将事务中所做的操作捆绑成一个原子单元,即对于事务所进行的数据修改等操作,要么全部执行,要么全部不执行。
一致性:事务在完成时,必须使所有的数据都保持一致状态,而且在相关数据中,所有规则都必须应用于事务的修改,以保持所有数据的完整性。事务结束时,所有的内部数据结构都应该是正确的。
隔离性:由并发事务所做的修改必须与任何其他事务所做的修改相隔离。事务查看数据时数据所处的状态,要么是被另一并发事务修改之前的状态,要么是被另一并发事务修改之后的状态,即事务不会查看由另一个并发事务正在修改的数据。这种隔离方式也叫可串行性。
持久性:事务完成之后,它对系统的影响是永久的,即使出现系统故障也是如此。

3 事务隔离

脏读(Dirty Read)
不可重读(Unrepeatable read)
幻读(Phantom Read)
 脏数据(Dirty Read):如果第二个应用程序使用了第一个应用程序修改过的数据,而这个数据处于未提交状态,这时就会发生脏读。第一个应用程序随后可能会请求回滚被修改的数据,从而导致第二个事务使用的数据被损坏,即所谓的“变脏”。
 不可重读(Unrepeatable Read):一个事务两次读同一行数据,可是这两次读到的数据不一样,就叫不可重读。如果一个事务在提交数据之前,另一个事务可以修改和删除这些数据,就会发生不可重读。
 幻读(Phantom Read):一个事务执行了两次查询,发现第二次查询结果比第一次查询多出了一行,这可能是因为另一个事务在这两次查询之间插入了新行。

针对由事务的不完全隔离所引起的上述问题,提出了一些隔离级别,用来防范这些问题。
 读操作未提交(Read Uncommitted)1级:说明一个事务在提交前,其变化对于其他事务来说是可见的。这样脏读、不可重读和幻读都是允许的。当一个事务已经写入一行数据但未提交,其他事务都不能再写入此行数据;但是,任何事务都可以读任何数据。这个隔离级别使用排写锁实现。
 读操作已提交(Read Committed)2级:读取未提交的数据是不允许的,它使用临时的共读锁和排写锁实现。这种隔离级别不允许脏读,但不可重读和幻读是允许的。
 可重读(Repeatable Read)4级:说明事务保证能够再次读取相同的数据而不会失败。此隔离级别不允许脏读和不可重读,但幻读会出现。
 可串行化(Serializable)8级:提供最严格的事务隔离。这个隔离级别不允许事务并行执行,只允许串行执行。这样,脏读、不可重读或幻读都可发生。

这里写图片描述

在一个实际应用中,开发者经常不能确定使用什么样的隔离级别。太严厉的级别将降低并发事务的性能,但是不足够的隔离级别又会产生一些小的Bug,而这些Bug只会在系统重负荷(也就是并发严重时)的情况下才会出现。
一般来说,读操作未提交(Read Uncommitted)是很危险的。一个事务的回滚或失败都会影响到另一个并行的事务,或者说在内存中留下和数据库中不一致的数据。这些数据可能会被另一个事务读取并提交到数据库中。这是完全不允许的。
另外,大部分程序并不需要可串行化隔离(Serializable Isolation)。虽然,它不允许幻读,但一般来说,幻读并不是一个大问题。可串行化隔离需要很大的系统开支,很少有人在实际开发中使用这种事务隔离模式。
现在留下来的可选的隔离级别是读操作已提交(Read Committed)和可重读(Repeatable Read)。hibernate可以很好地支持可重读(Repeatable Read)隔离级别。

4 在Hibernate配置文件中设置隔离级别

hibernate.properties中,可以修改隔离级别,应把此语句行前的注释符“#”去掉:

#hibernate.connection.isolation 4

hibernate.cfg.xml中加入以下代码,把隔离级别设置为4:

<property name=” hibernate.connection.isolation”>4</property>

MySQL的事物级别是4。在开始一个事务之前,Hibernate从配置文件中获得隔离级别的值。

5 事务规范代码

public class UserTrans {
        @Test
        public void testTx(){
            SessionFactory sessionFactory=null;
            Session session=null;
            Transaction tx=null;
            try {
                sessionFactory=UserUntil.getSessionFactory();
                session=sessionFactory.openSession();
                //开始事务

                //添加
                tx=session.beginTransaction();
                User user=new User();
                user.setUsername("qqqqeww");
                user.setPassword("12345");
                session.save(user);

                //提交事务
                tx.commit();
            } catch (Exception e) {
                tx.rollback();
            }finally{
                session.close();
                sessionFactory.close();
            }
        }
}

参考文档:
http://blog.csdn.net/lifaming15/article/details/2564660

 

二、Hibernate缓存机制

一级缓存是默认打开的
一级缓存范围:从session创建到session关闭范围
一级缓存中存储的数据必须是持久态数据
sesion的三种状态: 瞬时状态 (Transient),持久状态 (Persistent),脱管状态 (Detached)

        //第一次查询
        User user=session.get(User.class, 2);
        System.out.println(user);
        //第二次查询
        User user2=session.get(User.class, 2);
        System.out.println(user2);

 

第二次查询的时候不会查询数据库,会在一级缓存(内存)中查询。

二级缓存被Redis替代了
二级缓存默认不是打开的,需要配置
二级缓存使用范围是sesionFactory范围

参考文档:

sesion的三种状态
http://www.cnblogs.com/youk/archive/2011/11/25/2262596.html
hibernate 缓存机制
http://www.cnblogs.com/wean/archive/2012/05/16/2502724.html
梳理hibernate篇-原理及缓存机制
http://blog.csdn.net/u014586894/article/details/51630562

Hibernate CRUD

所需jar包

hibernate-release-5.0.7.Final 下的lib下的jpa和required

这里写图片描述

用到了单元测试,所以需要添加JUnit 4

User.Java

package cn.hiber;

public class User {
        private int id;
        private String username;
        private String password;
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        public String getUsername() {
            return username;
        }
        public void setUsername(String username) {
            this.username = username;
        }
        public String getPassword() {
            return password;
        }
        public void setPassword(String password) {
            this.password = password;
        }
                @Override
        public String toString() {
            return "User [id=" + id + ", username=" + username + ", password="
                    + password + "]";
        }
}

User.hbm.xml

<?xml version='1.0' encoding='utf-8'?>  
<!DOCTYPE hibernate-mapping PUBLIC  
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">  
<hibernate-mapping>  

    <class name="cn.hiber.User" table="t_user" schema="hibernate">  
        <id name="id" column="id">  
            <!--指定主键生成方式,native:使用数据库本地方式-->  
            <generator class="native" />  
        </id>  
        <property name="username" column="username"/>  
        <property name="password" column="password"/>  

    </class>  
</hibernate-mapping>  

hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?>  
<!DOCTYPE hibernate-configuration PUBLIC  
        "-//Hibernate/Hibernate Configuration DTD//EN"  
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">  
<hibernate-configuration>  
    <session-factory>  
        <!--数据库信息-->  
        <property name="connection.username">root</property>  
        <property name="connection.password">root</property>  
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>  
        <property name="connection.url">jdbc:mysql:///test</property>  

        <!--hibernate基本信息-->  
        <!--hibernate使用的数据库方言-->  
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>  
        <!--执行操作时,是否在控制台打印SQL-->  
        <property name="show_sql">true</property>  
        <!--是否对SQL格式化-->  
        <property name="format_sql">true</property>  
        <!--指定声称数据库表的策略-->  
        <property name="hbm2ddl.auto">update</property>  
        <!--指定关联的.hbm.xml文件-->  
        <mapping resource="cn/hiber/User.hbm.xml"/>  
    </session-factory>  
</hibernate-configuration>  

UserUntil.java

package cn.hiber;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class UserUntil {
    static Configuration cfg=null;
    static SessionFactory sessionFactory=null;
    static{
        cfg=new Configuration().configure();
        sessionFactory=cfg.buildSessionFactory();

    }
    public static SessionFactory getSessionFactory() {
        // TODO Auto-generated method stub
        return sessionFactory;
    }
}

UserTest.java

package cn.hiber;

import org.hibernate.Session;  
import org.hibernate.SessionFactory;  
import org.hibernate.Transaction;  
import org.hibernate.cfg.Configuration;  
import org.junit.Test;


public class UserTest {  

    @Test
    public void addtest(){
/*
        //加载hibernate配置文件,封装对象
        Configuration cfg= new Configuration().configure();  
        //读取配置文件,创建sessionFactory,把表创建
        SessionFactory sessionFactory = cfg.buildSessionFactory(); */ 
        SessionFactory sessionFactory=UserUntil.getSessionFactory();
        //类似连接 
        Session session = sessionFactory.openSession();  
        //开启事务  
        Transaction tx= session.beginTransaction();  

        //执行保存操作  
        User user=new User();
        user.setUsername("sssss");
        user.setPassword("123456");
        session.save(user);

        //提交事务  
        tx.commit();   
        //关闭Session  
        session.close();  
        //关闭SessionFactory  
        sessionFactory.close();  
    }  
    @Test
    public void gettest(){
/*
        //加载hibernate配置文件,封装对象
        Configuration cfg= new Configuration().configure();  
        //读取配置文件,创建sessionFactory,把表创建
        SessionFactory sessionFactory = cfg.buildSessionFactory(); */ 
        SessionFactory sessionFactory=UserUntil.getSessionFactory();
        //类似连接 
        Session session = sessionFactory.openSession();  
        //开启事务  
        Transaction tx= session.beginTransaction();  

        //执行根据ID查询操作 ,先生成toString
        User user=session.get(User.class, 2);
        System.out.println(user);

        //提交事务  
        tx.commit();   
        //关闭Session  
        session.close();  
        //关闭SessionFactory  
        sessionFactory.close();  
    }  
    @Test
    public void updatetest(){
/*
        //加载hibernate配置文件,封装对象
        Configuration cfg= new Configuration().configure();  
        //读取配置文件,创建sessionFactory,把表创建
        SessionFactory sessionFactory = cfg.buildSessionFactory(); */ 
        SessionFactory sessionFactory=UserUntil.getSessionFactory();
        //类似连接 
        Session session = sessionFactory.openSession();  
        //开启事务  
        Transaction tx= session.beginTransaction();  

        //执行根据ID查询操作 ,再update。
        //删除的话就是sesion.delete(user);
        User user=session.get(User.class, 2);
        user.setUsername("ccccc");
        session.update(user);

        //提交事务  
        tx.commit();   
        //关闭Session  
        session.close();  
        //关闭SessionFactory  
        sessionFactory.close();  
    }  

}  

参考文档:

http://blog.csdn.net/a1610770854/article/details/51939473
http://blog.csdn.net/shrek_xu/article/details/740991

 

hibernate session绑定查询

1.在hibernate.cfg.xml中加入:

<property name="hibernate.current_session_context_class">thread</property> 

2.在sessionFactory方法中获取
在UserUntil.Java中加入

//返回与本地线程绑定的session的方法
    public static Session getSessionobj(){
        return sessionFactory.getCurrentSession();
    }

3.UserTrans.java

package cn.hiber;

import org.hibernate.Session;
/*import org.hibernate.SessionFactory;*/
import org.hibernate.Transaction;
import org.junit.Test;

public class UserTrans {
        @Test
        public void testTx(){
            /*SessionFactory sessionFactory=null;*/
            Session session=null;
            Transaction tx=null;
            try {
/*              sessionFactory=UserUntil.getSessionFactory();
                session=sessionFactory.openSession();*/

                //获取本地线程绑定的session
                session=UserUntil.getSessionobj();
                //开始事务
                tx=session.beginTransaction();

                //添加
                User user=new User();
                user.setUsername("qqqqeww");
                user.setPassword("12345");
                session.save(user);

                //提交事务
                tx.commit();
            } catch (Exception e) {
                tx.rollback();
            }/*finally{
                session.close();
                sessionFactory.close();
            }*/
        }
}

 

 

 

JDBC+mysql遍历

import java.sql.*;

public class Main {

    public static void main(String[] args) {
        String driver = "com.mysql.jdbc.Driver";
        String url = "jdbc:mysql://localhost:3306/test";
        String username = "root";
        String password = "root";
        String sql = "select * from user ";

        Connection conn = null;
        PreparedStatement pre=null;
        ResultSet res=null;
        try {
            Class.forName(driver); //classLoader,加载对应驱动

            conn = (Connection)DriverManager.getConnection(url, username, password);
            pre=conn.prepareStatement(sql);
            res=pre.executeQuery();

            int col = res.getMetaData().getColumnCount();
            while (res.next()){
                for (int i = 1; i <= col; i++) {
                    System.out.print(res.getString(i) + "\t");
                }
                //查完一行换行
                System.out.println();
            }
         System.out.println("查完了");
        res.close();
        pre.close();
        conn.close();

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }
}

 

Spring 学习笔记

Spring是什么?

Spring是一个容器框架,它可以管理web层,业务层,dao层,持久层的各个组件。并且可以配置各种bean,且它维护bean与bean之间关系的框架。当使用某个bean的时候,可以getBean(id)来实现。

IoC是什么?

IoC (inverse of controller)控制反转:所谓控制反转就是把创建对象(bean),和维护对象(bean)的关系的权利从程序中转移到Spring的容器(applicationContext.xml)中,而程序本身不在维护。

DI是什么?

di(dependency injection)依赖注入:实际上di和ioc是同一个概念,Spring设计者认为di更准确表示Spring核心技术。

文档:

Spring IoC原理

http://blog.csdn.NET/it_man/article/details/4402245

http://blog.csdn.Net/m13666368773/article/details/7802126

关于bean:

1.如果使用ApplicationContext ,则配置的bean如果是 singlton(单例)不管你用不用,都被实例化.(好处就是可以预先加载,缺点就是耗内存)

2.如果是 BeanFactory ,则当你获取beanfacotry时候,配置的bean不会被马上实例化,当你使用的时候,才被实例(好处节约内存,缺点就是速度)

bean的作用域:

Spring AOP是什么?

AOP(Aspect Oriented Programming)面向切面编程,面向方面编程

AOP核心概念:

参考:

Spring AOP实现原理

http://blog.csdn.net/moreevan/article/details/11977115/

Spring AOP详解

http://www.cnblogs.com/hongwz/p/5764917.html

 

 

 

spring 中bean 的生命周期短暂吗?

在spring中,从BeanFactory或ApplicationContext取得的实例为Singleton,也就是预设为每一个Bean的别名只能维持一个实例,而不是每次都产生一个新的对象使用Singleton模式产生单一实例,对单线程的程序说并不会有什么问题,但对于多线程的程序,就必须注意安全(Thread-safe)的议题,防止多个线程同时存取共享资源所引发的数据不同步问题。

然而在spring中 可以设定每次从BeanFactory或ApplicationContext指定别名并取得Bean时都产生一个新的实例:例如:

在spring中,singleton属性默认是true,只有设定为false,则每次指定别名取得的Bean时都会产生一个新的实例

一个Bean从创建到销毁,如果是用BeanFactory来生成,管理Bean的话,会经历几个执行阶段(如图1.1):

1:Bean的建立:

容器寻找Bean的定义信息并将其实例化。

2:属性注入:

使用依赖注入,Spring按照Bean定义信息配置Bean所有属性

3:BeanNameAware的setBeanName():

如果Bean类有实现org.springframework.beans.BeanNameAware接口,工厂调用Bean的setBeanName()方法传递Bean的ID。

4:BeanFactoryAware的setBeanFactory():

如果Bean类有实现org.springframework.beans.factory.BeanFactoryAware接口,工厂调用setBeanFactory()方法传入工厂自身。

5:BeanPostProcessors的ProcessBeforeInitialization()

如果有org.springframework.beans.factory.config.BeanPostProcessors和Bean关联,那么其postProcessBeforeInitialization()方法将被将被调用。

6:initializingBean的afterPropertiesSet():

如果Bean类已实现org.springframework.beans.factory.InitializingBean接口,则执行他的afterProPertiesSet()方法

7:Bean定义文件中定义init-method:

可以在Bean定义文件中使用”init-method”属性设定方法名称例如:

如果有以上设置的话,则执行到这个阶段,就会执行initBean()方法

8:BeanPostProcessors的ProcessaAfterInitialization()

如果有任何的BeanPostProcessors实例与Bean实例关联,则执行BeanPostProcessors实例的ProcessaAfterInitialization()方法

此时,Bean已经可以被应用系统使用,并且将保留在BeanFactory中知道它不在被使用。有两种方法可以将其从BeanFactory中删除掉(如图1.2):

1:DisposableBean的destroy()

在容器关闭时,如果Bean类有实现org.springframework.beans.factory.DisposableBean接口,则执行他的destroy()方法

2:Bean定义文件中定义destroy-method

在容器关闭时,可以在Bean定义文件中使用”destroy-method”属性设定方法名称,例如:

如果有以上设定的话,则进行至这个阶段时,就会执行destroy()方法,如果是使用ApplicationContext来生成并管理Bean的话则稍有不同,使用ApplicationContext来生成及管理Bean实例的话,在执行BeanFactoryAware的setBeanFactory()阶段后,若Bean类上有实现org.springframework.context.ApplicationContextAware接口,则执行其setApplicationContext()方法,接着才执行BeanPostProcessors的ProcessBeforeInitialization()及之后的流程。

参考:http://developer.51cto.com/art/201104/255961.htm