大数据之路week05--day07（序列化、类加载器、反射、动态代理）
遇到这个 Java Serializable 序列化这个接口，我们可能会有如下的问题
a，什么叫序列化和反序列化
b，作用。为啥要实现这个 Serializable 接口，也就是为啥要序列化
c，serialVersionUID 这个的值到底是在怎么设置的，有什么用。有的是1L，有的是一长串数字，迷惑ing。
我刚刚见到这个关键字 Serializable 的时候，就有如上的这么些问题。
在处理这个问题之前，你要先知道一个问题，这个比较重要。
这个Serializable接口，以及相关的东西，全部都在 Java io 里面的。
序列化和反序列化的概念
序列化：把对象转换为字节序列的过程称为对象的序列化。
反序列化：把字节序列恢复为对象的过程称为对象的反序列化。
上面是专业的解释，现在来点通俗的解释。在代码运行的时候，我们可以看到很多的对象(debug过的都造吧)，
可以是一个，也可以是一类对象的集合，很多的对象数据，这些数据中，
有些信息我们想让他持久的保存起来，那么这个序列化。
就是把内存里面的这些对象给变成一连串的字节描述的过程。
常见的就是变成文件
我不序列化也可以保存文件啥的呀，有什么影响呢？我也是这么问的。
什么情况下需要序列化
当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
当你想用套接字在网络上传送对象的时候；
当你想通过RMI传输对象的时候；
(老实说，上面的几种，我可能就用过个存数据库的)
序列化流:把对象按照流一样的方式存入文本文件或者在网络中传输。对象 -- >流数据
ObjectOutputStream
反序列化流:把文本文件中的流对象数据或者网络中的流数据还原成对象。流数据 -->对象
ObjectInputStream
实现方式：
1、创建类对象，实现Serializable接口，这里要注意，可能还需要使用以前写过的数据，不能重新写入，怎么办呢？回想一下原因是因为他们的id值不匹配。每次修改Java文件的时候，class文件的id值就都会发生改变。而读取文件的时候，会和class文件中的id值进行匹配。所以会在这里出错。点击鼠标黄色警告线，产生一个序列化id值，在产生这个值以后，我 1 package com 2
import java.io.Serializable; /** * 创建时间：2019年12月8日 上午10:37:39 * 项目名称：practise11_IO流之序列化流 * @author WYH * @version 1.0 * @since JDK 1.8.0 * 文件名称：Person.java * 类说明：
*
* public interface Serializable类的序列化由实现java.io.Serializable接口的类启用。 不实现此接口的类将不会使任何状态序列化或反序列化。
*
*
* com.wyh.序列化流.Person; local class incompatible:
* stream classdesc serialVersionUID = 6648182538968226975,
* local class serialVersionUID = -45489707125759941 */ public class Person implements Serializable {
/**
*
*/
private static final long serialVersionUID = 5318313058664051662L;
private String name;
private int age;
// int age;
//如果该成员变量不想被序列化，加transient关键字
// private transient int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person() {
super();
// TODO Auto-generated constructor stub
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
以后我们如果看到类实现了这个接口，我们就要意识到，该对象可以被写入到文件，也可以在网络上被当作流一样传输。我一个类中可能有很多的成员变量，有些我不想序列化，请问怎么办呢？上面代码其实给出了，使用transient关键字声明不需要序列化的成员变量。
test
package com.wyh.序列化流; import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream; /** * 创建时间：2019年12月8日 上午10:36:40 * 项目名称：practise11_IO流之序列化流 * @author WYH * @version 1.0 * @since JDK 1.8.0 * 文件名称：ObjectOutputStream.java * 类说明：
* 序列化
* 反序列化 */ public class ObjectOutputStreamDemo { public static void main(String[] args) throws IOException, ClassNotFoundException {
//因为是针对对象操作的，所以我们要造一个实体类
write();
read();
} private static void read() throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt"));
Object obj = ois.readObject();
System.out.println(obj);
ois.close(); } private static void write() throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));
Person p = new Person("李智恩",20); oos.writeObject(p);
oos.close(); } }
类加载器
类的加载
当程序要使用某个类的时候，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化散步来实现对这个类进行初始化。
加载
就是指将class文件读入内存，并为之创建一个Class对象。
任何类被使用时系统都会建立一个Class对象。
连接
验证 是否有正确的内部结构，并和其他类协调一致
准备 负责为类的静态成员分配内存，并设置默认的初始化值
解析 将类的二进制数据中的符号引用替换为直接引用
初始化 就是我们以前讲过的初始化步骤
类初始化时机
创建类的实例
访问类的静态变量，或者为静态变量赋值
调用类的静态方法
使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
初始化某个类的子类
直接使用java.exe命令来运行某个主类
类加载器
负责将.class文件加载到内存中，并为之生成对应的Class对象。
虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行。
类加载器的组成
Bootstrap ClassLoader 根类加载器
Extendsion ClassLoader 扩展类加载器
System ClassLoader 系统类加载器
类加载器的作用
Bootstrap ClassLoader 根类加载器
也被称为引导类加载器，负责Java核心类的加载
比如System,String等。在JDK中JRE的lib目录下rt.jar文件中。
Extendsion ClassLoader 扩展类加载器
负责JRE扩展目录中jar包的加载。
在JDK中JRE的lib目录下ext目录中
System ClassLoader 系统类加载器
负责在JVM启动时加载来自Java命令的class文件，以及classpath环境变量所指定的jar包和类路径。
那么，如何使用累加器产生的.class文件呢？
那就是：反射
JAVA反射机制时在运行状态中，对任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法对的功能称之为Java语言的反射机制。
要想解剖一个类，必须先要获取到该类的字节码文件对象。而加平剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象。
获取class文件对象有三种方式：
A: Object类中的getClass()方法
B: 数据类型的静态属性Class
C: Class类中的静态方法
注意，要写类的全路径（也就是带包名的全路径），以后看到类似的也是这么写。
代码演示：
Person类：
package com.wyh.itcast01;
/**
* 创建时间：2019年12月8日 下午1:45:03
* 项目名称：practise12_反射
* @author WYH
* @version 1.0
* @since JDK 1.8.0
* 文件名称：Person.java
* 类说明：
*/
public class Person {
private String name;
int age;
public String address;
public Person(){
}
private Person(String name){
this.name = name;
}
Person(String name,int age){
this.name = name;
this.age = age;
}
public Person(String name,int age,String address){
this.name = name;
this.age = age;
this.address = address;
}
public void show(){
System.out.println("show");
}
private void method(String s){
System.out.println("method"+s);
}
public String getString(String s,int i){
return s+"---"+i;
}
public void function(){
System.out.println("function");
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", address=" + address
+ "]";
}
}
测试类：
package com.wyh.itcast01; /** * 创建时间：2019年12月8日 下午1:41:22 * 项目名称：practise12_反射 * @author WYH * @version 1.0 * @since JDK 1.8.0 * 文件名称：ReflactDemo.java * 类说明：
* 反射获取Class文件对象的三种方式 */ public class ReflactDemo {
public static void main(String[] args) throws ClassNotFoundException {
//第一种方式
Person p = new Person();
Class c = p.getClass(); Person p2 = new Person();
Class c2 = p2.getClass();
System.out.println(p==p2);//false
System.out.println(c==c2);//true //第二种方式
Class c3 = Person.class;
System.out.println(c==c3);//true //第三种方式
Class c4 = Class.forName("com.wyh.itcast01.Person");//注意这里写全路径
System.out.println(c==c4);//true 说明拿到的是同一个Class文件 } }
一般我们到底使用谁呢？
注意，一般我们自己学习或者练习的时候，任选一种，但是，实际开发过程中，我们选择第三种，因为第三种传的是一个字符串，而不是一个具体的类名，这样我们就可以把这样的字符串配置到配置文件中。
在我们知道怎么获取class字节码文件了之后，我们继续学习怎么获取构造方法，怎么创建对象，怎么获取成员方法并使用，怎么获取成员变量怎么使用？
1、通过反射获取构造方法
public Constructor[] getConstructors() 获取所有的公共的构造方法
public Constructor[] getDeclaredConstructors() 获取所有的构造方法，包括私有，默认
public Constructor<T> getConstructor(Class<?>...parameterTypes) 获取单个构造方法
Person类：
package com.wyh.itcast01;
/**
* 创建时间：2019年12月8日 下午1:45:03
* 项目名称：practise12_反射
* @author WYH
* @version 1.0
* @since JDK 1.8.0
* 文件名称：Person.java
* 类说明：
*/
public class Person {
private String name;
int age;
public String address;
public Person(){
}
private Person(String name){
this.name = name;
}
Person(String name,int age){
this.name = name;
this.age = age;
}
public Person(String name,int age,String address){
this.name = name;
this.age = age;
this.address = address;
}
public void show(){
System.out.println("show");
}
private void method(String s){
System.out.println("method"+s);
}
public String getString(String s,int i){
return s+"---"+i;
}
public void function(){
System.out.println("function");
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", address=" + address
+ "]";
}
}
通过反射获取无参构造方法并使用
package com.wyh.itcast02; import java.lang.reflect.Constructor; /** * 创建时间：2019年12月8日 下午2:29:03 * 项目名称：practise12_反射 * @author WYH * @version 1.0 * @since JDK 1.8.0 * 文件名称：ReflactDemo2.java * 类说明：'
* 通过反射获取无参构造方法并使用 */ public class ReflactDemo {
public static void main(String[] args) throws Exception {
//获取Class对象
Class c = Class.forName("com.wyh.itcast01.Person"); //获取多个构造方法
// getConstructors() 获取所有公共的
/*Constructor[] cos = c.getConstructors();
for(Constructor c1 : cos){
System.out.println(c1);
}*/ //getDeclaredConstructors() 获取所有的构造方法
Constructor[] cos = c.getDeclaredConstructors();
for(Constructor c1 : cos){
System.out.println(c1);
} //获取单个构造方法
Constructor c2 = c.getConstructor();
System.out.println(c2); //获取实例对象
Object obj = c2.newInstance();
System.out.println(obj); } }
通过反射获取带参构造方法并使用
package com.wyh.itcast02; import java.lang.reflect.Constructor; /** * 创建时间：2019年12月8日 下午2:29:03 * 项目名称：practise12_反射 * @author WYH * @version 1.0 * @since JDK 1.8.0 * 文件名称：ReflactDemo2.java * 类说明：'
* 通过反射获取带参构造方法并使用 */ public class ReflactDemo2 {
public static void main(String[] args) throws Exception {
//获取class文件
Class c = Class.forName("com.wyh.itcast01.Person");
//获取带参构造
Constructor c1 = c.getConstructor(String.class,int.class,String.class);
//利用带参构造创建实例
Object obj = c1.newInstance("李智恩",20,"安徽合肥");
System.out.println(obj); } }
通过反射获取私有的构造方法并使用
package com.wyh.itcast02; import java.lang.reflect.Constructor; /** * 创建时间：2019年12月8日 下午2:29:03 * 项目名称：practise12_反射 * @author WYH * @version 1.0 * @since JDK 1.8.0 * 文件名称：ReflactDemo2.java * 类说明：'
* 通过反射获取私有的构造方法并使用 */ public class ReflactDemo3 {
public static void main(String[] args) throws Exception {
//获取class文件
Class c = Class.forName("com.wyh.itcast01.Person");
//获取私有的构造方法
Constructor c1 = c.getDeclaredConstructor(String.class);
//实例化一个对象出来 //Class com.wyh.itcast02.ReflactDemo3 can not access a member of class com.wyh.itcast01.Person with modifiers "private"
//设置访问权限
c1.setAccessible(true);
Object obj = c1.newInstance("王友虎");
System.out.println(obj); } }
2、通过反射获取成员变量并使用
package com.wyh.itcast03; import java.lang.reflect.Constructor;
import java.lang.reflect.Field; /** * 创建时间：2019年12月8日 下午3:13:04 * 项目名称：practise12_反射 * @author WYH * @version 1.0 * @since JDK 1.8.0 * 文件名称：ReflactDemo.java * 类说明：
* 通过反射获取成员变量并使用 */ public class ReflactDemo {
public static void main(String[] args) throws Exception {
//获取class文件
Class c = Class.forName("com.wyh.itcast01.Person"); //获取所有公共的成员变量
// Field[] fields = c.getFields(); //获取所有的成员变量，包括私有的
Field[] fields = c.getDeclaredFields();
for(Field field : fields ){
System.out.println(field);
} //获取单个的成员变量
Field addressField = c.getField("address"); //获取单个的私有成员变量
Field nameField = c.getDeclaredField("name");
//同样需要进行权限设置
nameField.setAccessible(true); //获取单个成员变量（非私有也不是公共的）
Field ageField = c.getDeclaredField("age");
//同样需要进行权限设置
ageField.setAccessible(true); //获取无参构造
Constructor c1 = c.getConstructor();
//通过无参构造对象创建一个实例
Object obj = c1.newInstance();
System.out.println("未赋值之前:"+obj); //对获取到的非私有的成员变量进行赋值
addressField.set(obj, "中国安徽");
System.out.println("赋值了地址:"+obj); //对获取到的私有成员变量进行赋值
nameField.set(obj, "王友虎");
System.out.println("赋值了姓名:"+obj); //对获取到的非私有的也不是公共的成员变量进行赋值
ageField.set(obj, 22);//正确的读法：给obj对象的age进行赋值
System.out.println("赋值了年龄:"+obj); }
}
3、通过反射获取成员方法并使用
package com.wyh.itcast04; import java.lang.reflect.Constructor;
import java.lang.reflect.Method; /** * 创建时间：2019年12月8日 下午4:14:14 * 项目名称：practise12_反射 * @author WYH * @version 1.0 * @since JDK 1.8.0 * 文件名称：ReflactDemo.java * 类说明：
* 通过反射获取成员方法并使用 */ public class ReflactDemo {
public static void main(String[] args) throws Exception {
//获取Class对象
Class c = Class.forName("com.wyh.itcast01.Person"); //获取所有的公共方法(包括父类)
// Method[] methods = c.getMethods(); //获取自己的所有方法，包括私有方法
Method[] methods = c.getDeclaredMethods();
for(Method method : methods){
System.out.println(method);
} //获取无参构造方法
Constructor con = c.getConstructor();
//通过获取到的无参构造实例一个对象
Object obj = con.newInstance(); System.out.println("============"); //获单个的方法
//show()
Method showMethod = c.getMethod("show");//第一个参数是方法名，后面是class对象
//调用show方法 invoke(obj, args);
System.out.println("调用show方法:");
showMethod.invoke(obj); //getString(String,int)
Method getStringMethod = c.getMethod("getString", String.class,int.class);
System.out.println("调用getString方法:");
System.out.println(getStringMethod.invoke(obj, "小虎",22)); //method(String)
Method methodM = c.getDeclaredMethod("method", String.class);
methodM.setAccessible(true);//因为是私有的成员方法，所以同样需要进行设置权限
System.out.println("调用method方法:");
methodM.invoke(obj, "李智恩");//第一个参数是获取产生的对象名，第二个参数是要传的实际值 } }
实例1、通过反射读取xml文件，并使用
我们就用class.txt来代替，里面的写法是键值对写法
class.txt
ClassName=com.wyh.Test.Teacher
MethodName=love
编写三个类，学生类，老师类，工人类
Student:
package com.wyh.Test;
/**
* 创建时间：2019年12月8日 下午5:05:05
* 项目名称：practise12_反射
* @author WYH
* @version 1.0
* @since JDK 1.8.0
* 文件名称：Student.java
* 类说明：
*/
public class Student {
public void love(){
System.out.println("爱生活，爱Java");
}
}
teacher:
package com.wyh.Test;
/**
* 创建时间：2019年12月8日 下午5:05:42
* 项目名称：practise12_反射
* @author WYH
* @version 1.0
* @since JDK 1.8.0
* 文件名称：Teacher.java
* 类说明：
*/
public class Teacher {
public void love(){
System.out.println("爱生活，爱李智恩");
}
}
Worker类：
package com.wyh.Test;
/**
* 创建时间：2019年12月8日 下午5:06:00
* 项目名称：practise12_反射
* @author WYH
* @version 1.0
* @since JDK 1.8.0
* 文件名称：worker.java
* 类说明：
*/
public class worker {
public void love(){
System.out.println("爱生活，爱工作");
}
}
测试类：
package com.wyh.Test; import java.io.FileReader;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Properties; /** * 创建时间：2019年12月8日 下午5:06:15 * 项目名称：practise12_反射 * @author WYH * @version 1.0 * @since JDK 1.8.0 * 文件名称：test.java * 类说明： */ public class test {
public static void main(String[] args) throws Exception {
Properties prop = new Properties();
FileReader fr = new FileReader("class.txt");
prop.load(fr);
fr.close(); String className = prop.getProperty("ClassName");
String methodName = prop.getProperty("MethodName"); Class c = Class.forName(className);
Constructor con = c.getConstructor();
Object obj = con.newInstance(); Method m = c.getMethod(methodName);
m.invoke(obj); } }
实例2、在ArrayList<Integer>中添加字符串数据
在没学习反射之前集合中，如果添加了泛型控制，我们是没有办法进行这个操作的，但是今天看了源码之后，我们发现，这里的泛型只对编译器可见，底层是Object对象添加，所以这里，我们就可以使用反射拿到class文件，进行添加。
package com.wyh.Test02; import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.ArrayList; /** * 创建时间：2019年12月8日 下午7:11:31 * 项目名称：practise12_反射 * @author WYH * @version 1.0 * @since JDK 1.8.0 * 文件名称：ArrayListDemo.java * 类说明：
* 在ArrayList<Integer>中添加字符串数据 */ public class ArrayListDemo {
public static void main(String[] args) throws Exception {
ArrayList<Integer> arrays = new ArrayList<Integer>();
// arrays.add(e); //获取字节码文件的另一种方式
Class c = arrays.getClass(); Method m = c.getMethod("add", Object.class);
m.invoke(arrays, "Hello");
m.invoke(arrays, "world");
m.invoke(arrays, "java");
System.out.println(arrays);
for(Object o : arrays){
System.out.println(o);
} } }
实例3、实现方法：public void setProperty(Object obj,String propertyName,Object value){}，以后类可以通过这个方法进行赋值操作
Tool类：
package com.wyh.Test03; import java.lang.reflect.Field; /** * 创建时间：2019年12月8日 下午7:51:43 * 项目名称：practise12_反射 * @author WYH * @version 1.0 * @since JDK 1.8.0 * 文件名称：Tool.java * 类说明：
* 实现方法：
* public void setProperty(Object obj,String propertyName,Object value){} */ public class Tool {
public void setProperty(Object obj,String propertyName,Object value){
Class c = null;
Field f = null;
try{
c = obj.getClass();
f = c.getDeclaredField(propertyName);
f.setAccessible(true);
f.set(obj, value);
}catch(Exception e){
e.printStackTrace();
} } }
测试类：
package com.wyh.Test03;
/**
* 创建时间：2019年12月8日 下午7:55:42
* 项目名称：practise12_反射
* @author WYH
* @version 1.0
* @since JDK 1.8.0
* 文件名称：ToolTest.java
* 类说明：
*/
public class ToolTest {
public static void main(String[] args) {
Person p = new Person();
Tool t = new Tool();
t.setProperty(p, "name", "王友虎");
t.setProperty(p, "age", 22);
System.out.println(p);
}
}
class Person{
private String name;
int age;
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
动态代理
代理：本来应该自己做的事情，却请了别人来做，被请的人就是代理对象。
举例：春季回家买票让人去买
动态代理：在程序运行过程中产生的这个对象
而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理。
例子实现：有个UserDao的接口，有增删查改的方法，UserDaoImpl实现了这四个方法，但是我们需要在这个四个方法上添加权限检查和日志打印怎么办？如果我现在又增添了一个实体类，每个方法上也是需要这两个方法怎么办？
动态代理(实现InvocationHandler 接口并且重写public Object invoke(Object proxy, Method method, Object[] args){}方法)
UserDao:
package com.wyh.动态代理;
/**
* 创建时间：2019年12月8日 下午8:06:12
* 项目名称：practise12_反射
* @author WYH
* @version 1.0
* @since JDK 1.8.0
* 文件名称：UserDao.java
* 类说明：
*/
public interface UserDao {
public abstract void add();
public abstract void delete();
public abstract void update();
public abstract void find();
}
UserDaoImpl:
package com.wyh.动态代理;
/**
* 创建时间：2019年12月8日 下午8:07:44
* 项目名称：practise12_反射
* @author WYH
* @version 1.0
* @since JDK 1.8.0
* 文件名称：UserDaoImpl.java
* 类说明：
*/
public class UserDaoImpl implements UserDao {
@Override
public void add() {
System.out.println("添加用户");
}
@Override
public void delete() {
System.out.println("删除用户");
}
@Override
public void update() {
System.out.println("更新用户");
}
@Override
public void find() {
System.out.println("查询用户");
}
}
自定义代理类，实现接口并重写方法：
package com.wyh.动态代理; import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method; /** * 创建时间：2019年12月8日 下午10:46:29 * 项目名称：practise12_反射 * @author WYH * @version 1.0 * @since JDK 1.8.0 * 文件名称：MyInvocationHandler.java * 类说明：
* 创建一个代理类 */ public class MyInvocationHandler implements InvocationHandler {
private Object target; public MyInvocationHandler(Object target) {
this.target = target;
} @Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("权限校验。。。");
Thread.sleep(1000);
Object result = method.invoke(target, args);
System.out.println("日志记录。。。");
return result;
} }
主题类：
Proxy.newProxyInstance(user.getClass().getClassLoader(), user.getClass().getInterfaces(), h);
package com.wyh.动态代理; import java.lang.reflect.Proxy; /**
*
* 创建时间：2019年12月8日 下午10:44:59
*
* 项目名称：practise12_反射
*
* @author WYH
*
* @version 1.0
*
* @since JDK 1.8.0
*
* 文件名称：Test.java
*
* 类说明：
*/ public class Test {
public static void main(String[] args) {
UserDao user = new UserDaoImpl();
user.add();
user.delete();
user.update();
user.find(); System.out.println("--------------"); MyInvocationHandler handler = new MyInvocationHandler(user);
UserDao proxy = (UserDao) Proxy.newProxyInstance(user.getClass()
.getClassLoader(), user.getClass().getInterfaces(), handler);//返回的是Object对象，强转成我们需要的对象类型 proxy.add();
proxy.delete();
proxy.update();
proxy.find(); } }
大数据之路week05--day07（序列化、类加载器、反射、动态代理）的更多相关文章
- java--加强之 类加载器，动态代理
转载请申明出处:http://blog.csdn.net/xmxkf/article/details/9944561 ***************************************** ...
- C#码农的大数据之路 - 使用C#编写MR作业
系列目录 写在前面 从Hadoop出现至今,大数据几乎就是Java平台专属一般.虽然Hadoop或Spark也提供了接口可以与其他语言一起使用,但作为基于JVM运行的框架,Java系语言有着天生优势. ...
- 大数据之路week07--day03（Hadoop深入理解，JAVA代码编写WordCount程序，以及扩展升级）
什么是MapReduce 你想数出一摞牌中有多少张黑桃.直观方式是一张一张检查并且数出有多少张是黑桃. MapReduce方法则是: 1.给在座的所有玩家中分配这摞牌 2.让每个玩家数自己手中的牌有几 ...
- 大数据之路week04--day06（I/O流阶段一 之异常）
从这节开始,进入对I/O流的系统学习,I/O流在往后大数据的学习道路上尤为重要!!!极为重要,必须要提起重视,它与集合,多线程,网络编程,可以说在往后学习或者是工作上,起到一个基石的作用,没了地基,房 ...
- 胖子哥的大数据之路（11）-我看Intel&&Cloudera的合作
一.引言 5月8日,作为受邀嘉宾,参加了Intel与Cloudera在北京中国大饭店新闻发布会,两家公司宣布战略合作,该消息成为继Intel宣布放弃大数据平台之后的另外一个热点新闻.对于Intel的放 ...
- 胖子哥的大数据之路（10）- 基于Hive构建数据仓库实例
一.引言 基于Hive+Hadoop模式构建数据仓库,是大数据时代的一个不错的选择,本文以郑商所每日交易行情数据为案例,探讨数据Hive数据导入的操作实例. 二.源数据-每日行情数据 三.建表脚本 C ...
- 胖子哥的大数据之路（9）-数据仓库金融行业数据逻辑模型FS-LDM
引言: 大数据不是海市蜃楼,万丈高楼平地起只是意淫,大数据发展还要从点滴做起,基于大数据构建国家级.行业级数据中心的项目会越来越多,大数据只是技术,而非解决方案,同样面临数据组织模式,数据逻辑模式的问 ...
- 胖子哥的大数据之路（7）- 传统企业切入核心or外围
一.引言 昨天和一个做互联网大数据(零售行业)的朋友交流,关于大数据传统企业实施的切入点产生了争执,主要围绕两个问题进行了深入的探讨: 问题1:对于一个传统企业而言什么是核心业务,什么是外围业务? 问 ...
- 胖子哥的大数据之路（6）- NoSQL生态圈全景介绍
引言: NoSQL高级培训课程的基础理论篇的部分课件,是从一本英文原著中做的摘选,中文部分参考自互联网.给大家分享. 正文: The NoSQL Ecosystem 目录 The NoSQL Eco ...
随机推荐
- 【计算机视觉】Objectness算法（一）---总体理解，整理及总结
1.源码下载及转换为VS2012 WIN32版本. http://www.cnblogs.com/larch18/p/4560690.html 2.原文: http://wenku.baidu.com ...
- in-place数据交换
实现in-place的数据交换 声明:引用请注明出处http://blog.csdn.net/lg1259156776/ 经典的排序问题 问题描述 一个数组中包含两个已经排好序的子数组,设计一个in- ...
- Python中的并行编程速度
这里主要想记录下今天碰到的一个小知识点:Python中的并行编程速率如何? 我想把AutoTool做一个并行化改造,主要目的当然是想提高多任务的执行速度.第一反应就是想到用多线程执行不同模块任务,但是 ...
- python学习-47 random模块
random模块 随机模块 random 的方法: print(random.random()) # [0,1] 的浮点数 print(random.randint(1,3)) print(rando ...
- Django之ORM表操作
ORM表操作 1.ORM单表操作 首先想操作表的增删改查,需要先导入这个表,以之前创建的UserInfo表为例,在app下的views.py中导入 from app import models def ...
- （九）SpringBoot之错误处理
一.错误处理方法 1.Spring Boot 将所有的错误默认映射到/error, 实现ErrorController 2.添加自定义的错误页面 二.Spring Boot 将所有的错误默认映射到 ...
- JDBC 复习1 DBUtil
package dbex; import java.io.Closeable; import java.io.IOException; import java.io.InputStream; impo ...
- 初试Maven
1 [检查]确认已经安装jdk,已经环境变量中配置JAVA_HOME,已经修改Path 2 [下载]从http://maven.apache.org/download.cgi下载所需要的版本,笔者使用 ...
- Spring IOC原理分析
IOC IOC(Inversion of Control)控制反转:所谓的控制反转,就是把原先需要我们代码自己实现对象的创建和依赖,反转给容器来实现.那么必然Spring需要创建一个容器,同时需要创建 ...
- LeetCode：626.换座位
题目链接:https://leetcode-cn.com/problems/exchange-seats/ 题目 小美是一所中学的信息科技老师,她有一张 seat 座位表,平时用来储存学生名字和与他们 ...