YanZi_33
YanZi_33

设计模式与架构02 -- 单例模式，工厂模式

单例模式

  • 单例模式是最简单的设计模式之一，属于创建型模式，它提供了一种创建对象的最佳方式；
  • 单例模式只涉及到一个单一的类，该类负责创建自己的对象，同时确保只会创建唯一的一个实例对象；
单例模式的实现

  • 单例模式的实现分为两种：

    • 饿汉式：类加载就会导致该单实例对象被创建；
    • 懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会被创建；

  • 饿汉式单例模式 静态变量方式 案例代码如下：

public class Singleton {

    //1.私有构造方法
    private Singleton() {}

    //2.在本类中创建实例对象
    private static Singleton instance = new Singleton();

    //3.提供一个公共的访问方式，让外界访问
    public static Singleton getInstance() {
        return instance;
    }
}
  • 饿汉式单例模式 静态代码块方式 案例代码如下：
public class Singleton {
    //1.私有构造方法
    private Singleton() {}

    //2.定义静态成员变量
    private static Singleton instance;

    //3.在静态代码块中赋值
    static {
        instance = new Singleton();
    }
    
    public static Singleton getInstance() {
        return instance;
    }
}

  • 饿汉式单例模式，在类加载时就已经创建单实例对象，若没有使用单例类，就会造成内存的浪费；

  • 懒汉式单例模式 - 线程不安全方式

public class Singleton {
    //1.私有构造方法
    private Singleton() {}

    //2.定义静态成员变量
    private static Singleton instance;

    //3.提供一个公共的访问方式，让外界访问
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
  • 懒汉式单例模式 - 线程安全方式
public class Singleton {
    //1.私有构造方法
    private Singleton() {}

    //2.定义静态成员变量
    private static Singleton instance;

    //3.提供一个公共的访问方式，让外界访问
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

  • synchronized：线程同步锁；

  • 懒汉式单例模式 - 双重检查锁方式

public class Singleton {
    //1.私有构造方法
    private Singleton() {}

    //2.定义静态成员变量
    private static volatile Singleton instance;

    //3.提供一个公共的访问方式，让外界访问
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

  • 添加volatile关键字之后的双重检查锁模式，是一种比较好的单例实现模式，能够保证在多线程的情况下，线程安全也不会有性能问题；

  • 懒汉式单例模式 - 静态内部类方式

  • 静态内部类单例模式中，实例有内部类创建，由于JVM在加载外部类的过程中，是不会加载静态内部类的，只有内部类的属性，方法被调用时才会被加载，并初始化其静态属性，静态属性由于被static修饰，保证只被实例化一次，并且严格保证实例化顺序；

public class Singleton {
    //1.私有构造方法
    private Singleton() {}

    //2.定义一个静态内部类
    private static class SingletonHandler {
        //在内部类中声明并初始化外部类对象
        private static Singleton INSTANCE = new Singleton();
    }

    //3.提供一个公共的访问方式，让外界访问
    public static Singleton getInstance() {
        return SingletonHandler.INSTANCE;
    }
}

  • 第一次加载Singleton类时不会去初始化INSTANCE，只有第一次调用getInstance方法，虚拟机加载SingletonHandler类并初始化INSTANCE，这样不仅能确保线程安全，也能保证Singleton实例的唯一性；

  • 静态内部类单例模式时一种优秀的单例模式，是开源项目中比较常用的一种单例模式，在没有任何加锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费；

  • 饿汉式 -- 枚举方式

  • 枚举类实现单例模式是极力推荐的实现方式，因为枚举类型是线程安全的，并且只会加载一次，设计者充分利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所有单例实现中唯一不会被破坏的实现方式；

public enum Singleton {
    INSTANCE;
}
  • 序列化会破坏单例模式，使用上面创建的单例类，创建单例对象，枚举方式除外，案例代码如下：
import java.io.Serializable;

public class Singleton implements Serializable {
    //1.私有构造方法
    private Singleton() {}

    //2.定义一个静态内部类
    private static class SingletonHandler {
        //在内部类中声明并初始化外部类对象
        private static Singleton INSTANCE = new Singleton();
    }

    //3.提供一个公共的访问方式，让外界访问
    public static Singleton getInstance() {
        return SingletonHandler.INSTANCE;
    }
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //先写入文件
        try {
            writeObjectToFile();
        } catch (Exception e) {
            e.printStackTrace();
        }

        //两次读取文件的 获取的单例对象不同
        try {
            readObjectFromFile();
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            readObjectFromFile();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //往文件中写数据
    public static void writeObjectToFile() throws Exception {
        Singleton singleton = Singleton.getInstance();
        //创建对象输出流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("/Users/liyanyan33/Desktop/a.txt"));
        //写对象
        oos.writeObject(singleton);
        //释放资源
        oos.close();
    }

    //从文件中读数据
    public static void readObjectFromFile() throws Exception {
        //创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("/Users/liyanyan33/Desktop/a.txt"));
        //读取对象
        Singleton singleton = (Singleton)ois.readObject();
        System.out.println(singleton);
        //释放资源
        ois.close();
    }
}
  • 解决方案：在单例类中实现readResolve方法，原理在于Singleton singleton = (Singleton)ois.readObject()，底层会去判断调用readResolve方法，改进之后的代码如下所示：
import java.io.Serializable;

public class Singleton implements Serializable {
    //1.私有构造方法
    private Singleton() {}

    //2.定义一个静态内部类
    private static class SingletonHandler {
        //在内部类中声明并初始化外部类对象
        private static Singleton INSTANCE = new Singleton();
    }

    //3.提供一个公共的访问方式，让外界访问
    public static Singleton getInstance() {
        return SingletonHandler.INSTANCE;
    }

    //当进行反序列化是 会自动调用改方法 将改方法的返回值直接返回
    public Object readResolve() {
        return SingletonHandler.INSTANCE;
    }
}
  • 反射会破坏单例模式，使用上面创建的单例类(这里使用静态内部类的方式)，创建单例对象，枚举方式除外，案例代码如下：
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //获取Singleton类的字节码对象
        Class clazz = Singleton.class;
        try {
            //获取无参构造方法
            Constructor cons = clazz.getDeclaredConstructor();
            //取消访问检查
            cons.setAccessible(true);
            //创建单例对象
            Singleton instance1 = (Singleton) cons.newInstance();
            Singleton instance2 = (Singleton) cons.newInstance();
            //不等 说明反射破坏了单例模式
            System.out.println(instance1 == instance2);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}
  • 解决方案：代码如下：
public class Singleton  {
    
    private static boolean flag = false;
    
    //1.私有构造方法
    private Singleton() {
        //flag = true 表明非第一次访问
        //flag = false 表明第一次访问
        synchronized (Singleton.class) {
            if (flag) {
                throw  new RuntimeException("不能创建多个对象");
            }
            flag = true;
        }
    }

    //2.定义一个静态内部类
    private static class SingletonHandler {
        //在内部类中声明并初始化外部类对象
        private static Singleton INSTANCE = new Singleton();
    }

    //3.提供一个公共的访问方式，让外界访问
    public static Singleton getInstance() {
        return SingletonHandler.INSTANCE;
    }
}
  • 系统类RunTime就是一个单例模式类，源码如下：
public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}
}
  • 其采用的是饿汉式 -- 静态成员变量 的单例模式；

工厂模式

  • 首先我们通过一个实际案例，来慢慢引出工厂设计模式；
  • 设计一个咖啡店点餐系统，包含咖啡类与咖啡店类，UML类图如下：
image.png
  • 代码实现如下：
public abstract class Coffee {

    public abstract String getName();

    public void addMilk() {
        System.out.println("加奶");
    }

    public void addSugar() {
        System.out.println("加糖");
    }
}

public class AmericanCoffee extends Coffee{
    @Override
    public String getName() {
        return "美式咖啡";
    }
}

public class LatteCoffee extends Coffee{
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

public class CoffeeStore {
    //点咖啡
    public Coffee orderCoffee(String type) {
        Coffee coffee = null;
        if (type.equals("american")) {
            coffee = new AmericanCoffee();
        } else if (type.equals("latte")) {
            coffee = new LatteCoffee();
        } else {
            throw new RuntimeException("对不起，您所点的咖啡没有!");
        }
        coffee.addMilk();
        coffee.addSugar();
        return coffee;
    }
}

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        CoffeeStore coffeeStore = new CoffeeStore();
        coffeeStore.orderCoffee("latte");
    }
}
  • 上述实现了点咖啡的功能，现在我们需要新增一种英式咖啡，创建英式咖啡类继承自Coffee类，但还需要改CoffeeStore类的代码，这就违背了软件设计原则中的开闭原则，如果我们使用工厂来生产对象，CoffeeStore类就只和工厂打交道就可以了，若要更换咖啡对象，直接在工厂里更换该咖啡对象即可，达到CoffeeStore类与具体咖啡对象解耦的目的，所以说工厂模式的最大优点是：解耦；
简单工厂模式
  • 简单工厂模式不是一种设计模式，不属于23种设计模式之一，其是一种编程习惯；
  • 简单工厂模式包含的角色有：
    • 抽象产品：定义了产品的规范，描述了产品的主要特性和功能；
    • 具体产品：实现或者继承抽象产品的子类；
    • 具体工厂：提供了创建产品的方法，调用者通过该方法来创建产品；
  • 现在使用简单工厂模式对上面的案例进行改进，UML类图如下：
image.png
  • 代码实现如下：
public abstract class Coffee {

    public abstract String getName();

    public void addMilk() {
        System.out.println("加奶");
    }

    public void addSugar() {
        System.out.println("加糖");
    }
}

public class AmericanCoffee extends Coffee{
    @Override
    public String getName() {
        return "美式咖啡";
    }
}

public class LatteCoffee extends Coffee{
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

public class SimpleCoffeeFactory {
    public Coffee createCoffee(String type) {
        Coffee coffee = null;
        if (type.equals("american")) {
            coffee = new AmericanCoffee();
        } else if (type.equals("latte")) {
            coffee = new LatteCoffee();
        } else {
            throw new RuntimeException("对不起，您所点的咖啡没有!");
        }
        return coffee;
    }
}

public class CoffeeStore {
    //点咖啡
    public Coffee orderCoffee(String type) {
        //创建工厂
        SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
        //通过工厂 获取咖啡
        Coffee coffee = factory.createCoffee(type);

        coffee.addMilk();
        coffee.addSugar();
        return coffee;
    }
}

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        CoffeeStore coffeeStore = new CoffeeStore();
        coffeeStore.orderCoffee("latte");
    }
}

  • 简单工厂模式的优点：

    • CoffeeStore类实现了与具体咖啡类的解耦；
    • SimpleCoffeeFactory工厂类封装了创建对象的细节，将创建对象与业务逻辑(点咖啡)分离，这样以后就避免了修改客户( CoffeeStore类)代码，如果要新增具体产品，可直接修改SimpleCoffeeFactory工厂类，更容易扩展；

  • 简单工厂模式的缺点：

    • SimpleCoffeeFactory工厂类与具体咖啡类产生了耦合，如果后期新增一种咖啡，SimpleCoffeeFactory工厂类也需要修改代码，违背了开闭原则；
    • CoffeeStore类与SimpleCoffeeFactory工厂类产生耦合， CoffeeStore类可以看成是SimpleCoffeeFactory工厂类的客户，可能会有其他的客户类；

  • 在开发中，可以将简单工厂模式中创建对象的方法定义为静态方法，属于静态工厂模式，代码如下：

public class SimpleCoffeeFactory {
    public static Coffee createCoffee(String type) {
        Coffee coffee = null;
        if (type.equals("american")) {
            coffee = new AmericanCoffee();
        } else if (type.equals("latte")) {
            coffee = new LatteCoffee();
        } else {
            throw new RuntimeException("对不起，您所点的咖啡没有!");
        }
        return coffee;
    }
}

public class CoffeeStore {
    //点咖啡
    public Coffee orderCoffee(String type) {
        //通过工厂 获取咖啡
        Coffee coffee = SimpleCoffeeFactory.createCoffee(type);

        coffee.addMilk();
        coffee.addSugar();
        return coffee;
    }
}
工厂方法模式
  • 针对上述案例的缺点，可使用工厂方法模式完美解决，完全遵循开闭原则；
  • 工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪个产品对象，工厂方法使一个产品类的实例化延迟到其工厂的子类；
  • 工厂方法模式的角色：
    • 抽象工厂：提供创建产品的接口，调用者通过它访问具体工厂的工厂方法创建产品；
    • 具体工厂：主要是实现抽象工厂中抽象方法，完成具体产品的创建；
    • 抽象产品：定义了产品的规范接口，描述了产品的主要特性和功能；
    • 具体产品：实现了抽象产品定义的规范接口，由具体工厂来创建，它与具体工厂之间一一对应；
  • 使用工厂方法模式对上述案例进行改进，UML类图如下：
image.png
  • 代码实现如下：
//抽象产品类
public abstract class Coffee {
    public abstract String getName();

    public void addMilk() {
        System.out.println("加奶");
    }

    public void addSugar() {
        System.out.println("加糖");
    }
}

//具体产品类
public class AmericanCoffee extends Coffee{
    @Override
    public String getName() {
        return "美式咖啡0";
    }
}

//具体产品类
public class LatteCoffee extends Coffee{
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

//抽象工厂
public interface CoffeeFactory {
    public Coffee createCoffee();
}

//具体工厂类
public class AmericanCoffeeFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }
}

//具体工厂类
public class LatteCoffeeFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }
}

//客户端
public class CoffeeStore {
    //持有抽象工厂
    private CoffeeFactory factory;

    public void setFactory(CoffeeFactory factory) {
        this.factory = factory;
    }

    public Coffee orderCoffee() {
        Coffee coffee = factory.createCoffee();
        coffee.addSugar();
        coffee.addMilk();
        return coffee;
    }
}

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        CoffeeStore store = new CoffeeStore();
        //在使用是初始化具体的工厂
        AmericanCoffeeFactory acf = new AmericanCoffeeFactory();
        store.setFactory(acf);
        store.orderCoffee();
    }
}
  • 现在再新增一款咖啡，只需要创建一个具体工厂类和具体产品类，不会修改抽象工厂类和抽象产品了，符合开闭原则；
  • 工厂方法模式的优点：
    • 客户只需要知道具体工厂 就能获取到想要的具体产品，无需知道产品创建的细节；
    • 在系统新增产品时，只需要新增具体工厂类和具体产品类，无需对原工厂进行修改，满足开闭原则；
  • 工厂方法模式的缺点：
    • 每新增产品时， 都要新增具体工厂类和具体产品类，增加系统的复杂度；
抽象工厂模式
  • 产品类型：具体产品的抽象，例如拿铁咖啡与美式咖啡都属于咖啡；
  • 产品族：具体产品的抽象集合，例如咖啡与甜点构成一个产品族；
  • 抽象工厂模式是工厂方法模式的升级版，工厂方法模式只生产一种类型的产品，而抽象工厂模式可生产多个不同类型的产品；
  • 抽象工厂模式提供了一个 创建一组相关或相互依赖对象 的接口，且访问类无需指定具体产品类 就能获取到不同类型产品的模式结构；
  • 抽象工厂模式的角色有：
    • 抽象工厂：提供创建产品的接口，它包含多个创建产品的方法，可以创建多个不同类型的产品；
    • 具体工厂：主要是实现抽象工厂中多个抽象方法，完成具体产品的创建；
    • 抽象产品：定义了产品的规范接口，描述了产品的主要特性和功能，有多个抽象产品类；
    • 具体产品：实现了抽象产品定义的规范接口，由具体工厂来创建，它与具体工厂之间是多对一的关系；
  • 场景案例：现在咖啡店业务发生了变化，不仅要生产咖啡还要生产甜点，如提拉米苏，抹茶慕斯等，如果按照工厂方法模式进行设计，需要定义提拉米苏类，提拉米苏工厂类，抹茶慕斯类，抹茶慕斯工厂类以及甜品抽象类，出现类爆炸情况，其中拿铁咖啡与美式咖啡属于同一产品类型，提拉米苏与抹茶慕斯属于同一产品类型，拿铁咖啡与提拉米苏属于同一产品族假设属于(意大利风味)，美式咖啡与抹茶慕斯属于同一产品族假设属于(美式风味)，可采用抽象工厂模式，UML类图如下：
image.png
  • 代码实现如下：
//咖啡抽象类
public abstract class Coffee {
    public abstract String getName();

    public void addMilk() {
        System.out.println("加奶");
    }

    public void addSugar() {
        System.out.println("加糖");
    }
}

//具体产品类
public class AmericanCoffee extends Coffee{
    @Override
    public String getName() {
        return "美式咖啡";
    }
}

//具体产品类
public class LatteCoffee extends Coffee{
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

//甜点抽象类
public abstract class Dessert {
    abstract public void show();
}

//具体产品类
public class Trimisu extends Dessert{
    @Override
    public void show() {
        System.out.println("提拉米苏");
    }
}

//具体产品类
public class MachaMourse extends Dessert{
    @Override
    public void show() {
        System.out.println("抹茶慕斯");
    }
}

//抽象工厂类
public interface DessertFactory {
    public Coffee createCoffee();
    public Dessert createDessert();
}

//具体工厂类
public class AmericanDessertFactory implements DessertFactory{
    @Override
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }

    @Override
    public Dessert createDessert() {
        return new MachaMourse();
    }
}

//具体工厂类
public class ItalyDessertFactory implements DessertFactory{
    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }

    @Override
    public Dessert createDessert() {
        return new Trimisu();
    }
}

//客户端
public class CoffeeStore {

    private DessertFactory factory;

    public void setFactory(DessertFactory factory) {
        this.factory = factory;
    }

    public Coffee orderCoffee() {
        Coffee coffee = null;
        coffee = factory.createCoffee();
        coffee.addSugar();
        coffee.addMilk();
        return coffee;
    }

    public Dessert orderDessert() {
        Dessert dessert = null;
        dessert = factory.createDessert();
        dessert.show();
        return dessert;
    }
}

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        CoffeeStore store = new CoffeeStore();
        AmericanDessertFactory factory = new AmericanDessertFactory();
        store.setFactory(factory);
        store.orderCoffee();
        store.orderDessert();
    }
}
  • 如果要新增一个产品族，只需要再加一个对应的工厂类，不需要修改其他类；
  • 抽象工厂模式的优点：
    • 当产品族中的多个对象，被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象；
  • 抽象工厂模式的缺点：
    • 当产品族中需要新增一个新的产品时，所有的工厂类都需要进行修改；
  • 抽象工厂模式的使用场景：
    • 当需要创建的对象是一系列相互关联或相互依赖的产品族时，例如电器工厂中的电视机，洗衣机，空调等；
    • 系统中有多个产品族，但每次只使用其中的某一产品族时；
    • 系统中提供了产品的类库，且所有产品的接口都相同，客户端不依赖产品实例的创建细节与内部结构；
工厂模式的扩展
  • 可以通过简单工厂模式 + 配置文件的方式 解除工厂对象和产品对象的耦合，在工厂类中加载配置文件中的全类名，并创建对象进行存储，客户端如果需要对象，直接进行获取即可；
  • 第一步：定义配置文件，命名为bean.properties，文件内容如下：
american=com.example.sign.AmericanCoffee
latt=com.example.sign.LatteCoffee
  • 代码编写：
public class SimpleCoffeeFactory {

    //加载配置文件 获取配置文件中类名，并创建该对象进行存储
    //1.定义容器 存储对象
    private static HashMap map = new HashMap<>();
    //2.加载配置文件
    static {
        Properties p = new Properties();
        InputStream is = SimpleCoffeeFactory.class.getClassLoader().getResourceAsStream("bean.properties");
        //调用p的load方法 进行配置文件加载
        try {
            p.load(is);
            //从p集合中获取类名 创建对象
            Set keys = p.keySet();
            for (Object key: keys) {
                String className = p.getProperty((String) key);
                //通过反射技术创建对象
                Class clazz = Class.forName(className);
                Coffee coffee = (Coffee) clazz.newInstance();
                //将名称与对象 存储到容器中
                map.put((String) key,coffee);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static Coffee createCoffee(String name) {
        //通过名称 获取对象
        return map.get(name);
    }
}


import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        CoffeeStore store = new CoffeeStore();
        Coffee coffee = store.orderCoffee("latte");
        System.out.println(coffee.getName());
    }
}



    

  • 静态成员变量map 用来存储创建的对象，新增一种对象时，只需要修改配置文件即可；
    • 

























你可能感兴趣的:(设计模式与架构02 -- 单例模式，工厂模式)






    

  • 2020-01-25
晴岚85

    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
    

    • 

  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
黄错错加油

    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
    

    • 

  • 2021-08-26
影幽

    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
    

    • 

  • 抖音乐买买怎么加入赚钱?赚钱方法是什么
测评君高省

    你会在抖音买东西吗?如果会，那么一定要免费注册一个乐买买，抖音直播间，橱窗，小视频里的小黄车买东西都可以返佣金!省下来都是自己的，分享还可以赚钱乐买买是好省旗下的抖音返佣平台，乐买买分析社交电商的价值，乐买买属于今年难得的副业项目风口机会，2019年错过做好省的搞钱的黄金时期，那么2022年千万别再错过乐买买至于我为何转到高省呢？当然是高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自
    

    • 

  • 本周第二次约练
2cfbdfe28a51

    中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
    

    • 

  • 今日联对0306
诗图佳得

    自对联：烟销皓月临江浒，水漫金山荡塔裙。一一肖士平2020.3.6.1、试对肖老师联：烟销皓月临江浒，夜笼寒沙梦晚舟。耀哥求正2、试对萧老师联:烟销浩月临江浒，雾散乾坤解汉城。秀霞习作请各位老师校正3、自对联：烟销皓月临江浒，水漫金山荡塔裙。一一肖士平2020.3.6.4、试对肖老师垫场联：烟销皓月临江浒，雾锁寒林缈葉丛。小智求正[抱拳]5、试对肖老师联：烟销皓月临江浒；风卷乱云入峰巅。一一五品6
    

    • 

  • 2022-07-08
保利学府里李楚怡1307022

    ——保利碧桂园学府里——童梦奇趣【科学实验室】「7.9-7.10」✏玩出大智慧约99-144㎡二期全新升级力作
    

    • 

  • 2022-04-18
Apbenz

    语重心长的和我说，不要老是说不行，人至而立之年危机四伏，内在的，外在的，感觉就是心力憔悴，让人无所适从。面对职场的无情，突然好羡慕干体力劳动的外卖小哥。难道命运是想让我去送外卖了吗？干体力活才能让我活下去？fastadmin打卡成功,淘宝金币任务完成。ㅏㅓㅗㅜㅡㅣㅐㅔㅑㅕㅛㅠㅢㅒㅖY行。야자여자요리우유의사얘기예
    

    • 

  • 每日一题——第八十二题
互联网打工人no1
C语言程序设计每日一练c语言

    题目：将一个控制台输入的字符串中的所有元音字母复制到另一字符串中#include#include#include#include#defineMAX_INPUT1024boolisVowel(charp);intmain(){charinput[MAX_INPUT];charoutput[MAX_INPUT];printf("请输入一串字符串：\n");fgets(input,sizeof(inp
    

    • 

  • 每日一题——第八十三题
互联网打工人no1
C语言程序设计每日一练c语言

    题目：将输入的整形数字输出,输出1990，输出"1990"#include#defineMAX_INPUT1024intmain(){intarrr_num[MAX_INPUT];intnum,i=0;printf("请输入一个数字：");scanf_s("%d",&num);while(num!=0){arrr_num[i++]=num%10;num/=10;}printf("\"");for(
    

    • 

  • 509. 斐波那契数(每日一题)
lzyprime

    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
    

    • 

  • 2020.11.19
隆非凡

    日精进，今日体验：在维修过程中遇到的问题，把源头找到，在进行下一步开始。不要停留在一个点上，合理调整心态，把当下事做好。
    

    • 

  • 2018/02/12
Tracy_zhang

    人生并不在于获取，更在于放得下。放下一粒种子，收获一棵大树;放下一处烦恼，收获一个惊喜;放下一种偏见，收获一种幸福;放下一种执著，收获一种自在。放下既是一种理性抉择，也是一种豁达美。只要看得开放得下，何愁没有快乐的春莺在啼鸣，何愁没有快乐的泉溪在歌唱，何愁没有快乐的鲜花绽放!
    

    • 

  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
若博豆
java算法华为javascript

    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    

    • 

  • 2023-04-17|篮球女孩
长一木

    1小学抑或初中阶段，在课外书了解到她的故事。“篮球女孩”。当时佩服她的顽强，也对生命多了一丝敬畏。今天刚好在公众号看到，长大后的“篮球女孩”。佩服之余又满是心疼。网络侵删祝那素未蒙面的女孩，未来一切顺遂。
    

    • 

  • 高端密码学院笔记285
柚子_b4b4

    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
    

    • 

  • 2020-04-12每天三百字之连接与替代
冷眼看潮

    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
    

    • 

  • 春季养肝正当时
dxn悟

    重温快乐2023年2月4日立春。春天来了，春暖花开，小鸟欢唱，那在这样的季节我们如何养肝呢？自然界的春季对应中医五行的木，人体五脏肝属木，“木曰曲直”，是以树干曲曲直直地向上、向外伸长舒展的生发姿态，来形容具有生长、升发、条达、舒畅等特征的食物及现象。根据中医天人相应的理念，肝五行属木，喜条达，主疏泄，与春天相应，所以春天最适合养肝。养肝首先要少生气，因为肝喜条达恶抑郁。人体五志肝为怒，生气发怒最
    

    • 

  • 2022现在哪个打车软件比较好用又便宜 实惠的打车软件合集
高省APP珊珊

    这是一个信息高速传播的社会。信息可以通过手机，微信，自媒体，抖音等方式进行传播。但同时这也是一个交通四通发达的社会。高省APP，是2022年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入。珊珊导师，高省邀请码777777，注册送2皇冠会员，送万元推广大礼包，教你如何1年做到百万团队。高
    

    • 

  • 2023-10-22
奥雷里亚诺第n

    昨天在B站看到关于猫喜欢挠人的视频，视频教导说猫挠人的话就抓住它的后脖颈然后用手打打挠人的那个爪子。视频本身没什么，但评论区却炸开了锅（真是符合挑食者厌食心理）。令我印象最深刻的一个甚至上升到了关于我是谁这种终极问题。它说，猫就是畜生，它挠人就打它别惯着它，反正我六道轮回成了人就应该保持人的高贵，谁都别想来打破。我顿时汗颜，但看到下面全是类似的言论只不过后面的理由各有不同，本来想骂人的心都凉了一半
    

    • 

  • 2022-11-17
无奇君

    又去了一次社康，这次是急性支气管炎……太难了。半夜就猛咳，天天咳醒，还好他戴海绵耳塞睡吵不到他，要不然对他来说也是种煎熬。一累也会猛咳，希望这次是最后一次吃药，吃完就好。又想把头发剪短了，顺便染个色。可是刚刚去看人家还没开门，不是休息日老板好佛系。理发店是个夫妻店，一年多前刚搬来的时候老板还没对象呢，当时聊天老板就说希望能找个对象一起两个人守着店都比上班强。不久后再去他已经有对象了，而且在店里帮忙
    

    • 

  • 冬天短期的暴利小生意有哪些？那些小生意适合新手做？
一起高省

    短期生意不失为创业的一个商机，不过短期生意的商机是转瞬即逝的，而且这类生意也很难作为长期的生意去做，那冬天短期暴利小生意查看更多关于短期暴利小生意的文章有哪些呢?给大家先推荐一个2023年风口项目吧，真很不错的项目，全程零投资，当做副业来做真的很稳定，不管你什么阶层的人，或多或少都网购吧？你们知道网购是可以拿提成，拿返利，拿分佣的吗？你们知道很多优惠券群里面，天天群主和管理发一些商品吗？他们其实在
    

    • 

  • 怎么做淘客赚钱(2022最新免费淘客盈利的方法)
高省_飞智666600

    很多人都不知道什么是淘宝客，今天小编为大家解答一下吧。淘宝客，现在简称淘客，是时下比较流行的一个词语，特质为淘宝店推广商品获取提成的人，这些人没有自己的产品，只是在淘宝里面选择适合自己的产品，在自己比较熟悉的领域推广，把产品卖出去之后，会从淘宝店家那里获得百分之五到百分之五十左右的佣金。淘宝客付出的是什么呢？时间。你需要花时间去选适合自己推广的产品，需要花时间去选自己的推广方法，如果你打算自己做个
    

    • 

  • 2020-12-16
长寿富贵

    9：56不知今天哪位亲来说说话呀？成萌：尽尽皆是道。道道皆相同。不解呀？成萌：郁郁不得志，混混过日子。哦……说谁的呀？成萌：说自己呀……还能说谁呢？那如何办呢？成萌：回头……如何回头？成萌：回见心源。如何回见心源？成萌：不追不随诸相迁，如如不动在心田。啊？成萌：慢慢守心吧。
    

    • 

  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4)
算法大师
华为od面试python

    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
    

    • 

  • 【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1）
算法大师
华为od面试python算法前端

    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
    

    • 

  • 闲鱼鱼小铺怎么开通？鱼小铺开通需要哪些流程？
高省APP大九

    闲鱼鱼小铺是平台推出的一个专业程度的店铺，与普通店铺相比会有更多的权益，比如说发布的商品数量从50增加到500；拥有专业的店铺数据看板与分析的功能，这对于专门在闲鱼做生意的用户来说是非常有帮助的，那么鱼小铺每个人都能开通吗？大家好，我是高省APP联合创始人蓓蓓导师，高省APP是2021年推出的电商导购平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个可省钱佣金高，能
    

    • 

  • 直返APP是什么?直返APP是干嘛的
氧惠帮朋友一起省

    直返是一种电商购物模式，其核心特点是用户购买商品后可以获得直接返利。具体来说，用户在直返电商平台购买商品时，不仅可以获得商品本身的优惠，还可以获得一定的现金返利或者积分奖励。返利的金额可以提现到用户的账户余额，或者用于下次购物时抵扣。氧惠APP（带货领导者）——是与以往完全不同的抖客+淘客app！2023全新模式，我的直推也会放到你下面。主打：带货高补贴，深受各位带货团队长喜爱（每天出单带货几十万
    

    • 

  • 直返的东西正品吗?直返APP安全吗?直返是正规平台吗?
氧惠购物达人

    亲们，你们是不是经常在直返APP上买东西呀？但是，你们有没有想过，里面的东西到底是不是正品呢？这个APP安全吗？它是不是一个正规的平台呀？别着急，今天我就来给大家揭秘一下！氧惠APP（带货领导者）——是与以往完全不同的抖客+淘客app！2023全新模式，我的直推也会放到你下面。主打：带货高补贴，深受各位带货团队长喜爱（每天出单带货几十万单）。注册即可享受高补贴+0撸+捡漏等带货新体验。送万元推广大
    

    • 

  • 2020-12-24
我和我的天使们

    阅读《老子的心事》391—403“将欲取之，必固与之”：想要得到什么，首先就要送出什么。我常常对孩子们说，你希望别人怎样对你你就怎样对待别人。想要得到别人的尊重，首先要尊重别人。我希望她们可以不迟到，因为不迟到是对别人的尊重，我就自己就先做到不迟到。哪怕是约朋友逛街，我尽量准时赴约。我严格要求孩子们，也同样严格要求自己，我跟孩子们一起把好的品格变成习惯。“是谓微明”：这就是微妙的智慧。看起来很少很
    

    • 

  • 关于旗正规则引擎中的MD5加密问题
何必如此
jspMD5规则加密

    一般情况下，为了防止个人隐私的泄露，我们都会对用户登录密码进行加密，使数据库相应字段保存的是加密后的字符串，而非原始密码。
在旗正规则引擎中，通过外部调用，可以实现MD5的加密，具体步骤如下：
1.在对象库中选择外部调用，选择“com.flagleader.util.MD5”，在子选项中选择“com.flagleader.util.MD5.getMD5ofStr({arg1})”；
2.在规
    

    • 

  • 【Spark101】Scala Promise/Future在Spark中的应用
bit1129
Promise

    Promise和Future是Scala用于异步调用并实现结果汇集的并发原语，Scala的Future同JUC里面的Future接口含义相同，Promise理解起来就有些绕。等有时间了再仔细的研究下Promise和Future的语义以及应用场景，具体参见Scala在线文档：http://docs.scala-lang.org/sips/completed/futures-promises.html
    

    • 

  • spark sql 访问hive数据的配置详解
daizj
spark sqlhivethriftserver

    spark sql 能够通过thriftserver 访问hive数据，默认spark编译的版本是不支持访问hive，因为hive依赖比较多，因此打的包中不包含hive和thriftserver,因此需要自己下载源码进行编译，将hive，thriftserver打包进去才能够访问，详细配置步骤如下：
 
1、下载源码
 
2、下载Maven,并配置
此配置简单，就略过
    

    • 

  • HTTP 协议通信
周凡杨
javahttpclienthttp通信

     
                     
一：简介
 HTTPCLIENT，通过JAVA基于HTTP协议进行点与点间的通信！
 
 
二： 代码举例
 
   测试类：
import java
    

    • 

  • java unix时间戳转换
g21121
java

    把java时间戳转换成unix时间戳：
Timestamp appointTime=Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()))
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:m
    

    • 

  • web报表工具FineReport常用函数的用法总结（报表函数）
老A不折腾
web报表finereport总结

    说明：本次总结中，凡是以tableName或viewName作为参数因子的。函数在调用的时候均按照先从私有数据源中查找，然后再从公有数据源中查找的顺序。
 
CLASS
CLASS(object):返回object对象的所属的类。
 
CNMONEY
CNMONEY(number,unit)返回人民币大写。
number:需要转换的数值型的数。
unit:单位，
    

    • 

  • java jni调用c++ 代码 报错
墙头上一根草
javaC++jni

    #
# A fatal error has been detected by the Java Runtime Environment:
#
#  EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00000000777c3290, pid=5632, tid=6656
#
# JRE version: Java(TM) SE Ru
    

    • 

  • Spring中事件处理de小技巧
aijuans
springSpring 教程Spring 实例Spring 入门Spring3

    Spring 中提供一些Aware相关de接口，BeanFactoryAware、 ApplicationContextAware、ResourceLoaderAware、ServletContextAware等等，其中最常用到de匙ApplicationContextAware.实现ApplicationContextAwaredeBean，在Bean被初始后，将会被注入 Applicati
    

    • 

  • linux shell ls脚本样例
annan211
linuxlinux ls源码linux 源码

    
#! /bin/sh -
#查找输入文件的路径
#在查找路径下寻找一个或多个原始文件或文件模式
# 查找路径由特定的环境变量所定义
#标准输出所产生的结果 通常是查找路径下找到的每个文件的第一个实体的完整路径
# 或是filename :not found 的标准错误输出。
#如果文件没有找到 则退出码为0
#否则 即为找不到的文件个数
#语法 pathfind [--
    

    • 

  • List,Set,Map遍历方式 (收集的资源,值得看一下)
百合不是茶
listsetMap遍历方式

    List特点：元素有放入顺序，元素可重复
Map特点：元素按键值对存储，无放入顺序
Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的）
List接口有三个实现类：LinkedList，ArrayList，Vector
LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身
    

    • 

  • 解决SimpleDateFormat的线程不安全问题的方法
bijian1013
javathread线程安全

    在Java项目中，我们通常会自己写一个DateUtil类，处理日期和字符串的转换，如下所示：
public class DateUtil01 {
private SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public void format(Date d
    

    • 

  • http请求测试实例（采用fastjson解析）
bijian1013
http测试

            在实际开发中，我们经常会去做http请求的开发，下面则是如何请求的单元测试小实例，仅供参考。
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.httpclient.HttpClient;
import 
    

    • 

  • 【RPC框架Hessian三】Hessian 异常处理
bit1129
hessian

    RPC异常处理概述  
RPC异常处理指是，当客户端调用远端的服务，如果服务执行过程中发生异常，这个异常能否序列到客户端？
 
如果服务在执行过程中可能发生异常，那么在服务接口的声明中，就该声明该接口可能抛出的异常。
 
在Hessian中，服务器端发生异常，可以将异常信息从服务器端序列化到客户端，因为Exception本身是实现了Serializable的
    

    • 

  • 【日志分析】日志分析工具
bit1129
日志分析

    1. 网站日志实时分析工具 GoAccess
http://www.vpsee.com/2014/02/a-real-time-web-log-analyzer-goaccess/
2. 通过日志监控并收集 Java 应用程序性能数据(Perf4J)
http://www.ibm.com/developerworks/cn/java/j-lo-logforperf/
3.log.io
和
    

    • 

  • nginx优化加强战斗力及遇到的坑解决
ronin47
nginx 优化

    　　　先说遇到个坑，第一个是负载问题，这个问题与架构有关，由于我设计架构多了两层，结果导致会话负载只转向一个。解决这样的问题思路有两个：一是改变负载策略，二是更改架构设计。
　　　由于采用动静分离部署，而nginx又设计了静态，结果客户端去读nginx静态，访问量上来，页面加载很慢。解决：二者留其一。最好是保留apache服务器。
 
　　　来以下优化：
 
　　　 
    

    • 

  • java-50-输入两棵二叉树A和B，判断树B是不是A的子结构
bylijinnan
java

    思路来自：
http://zhedahht.blog.163.com/blog/static/25411174201011445550396/
import ljn.help.*;
public class HasSubtree {
/**Q50.
* 输入两棵二叉树A和B，判断树B是不是A的子结构。
例如，下图中的两棵树A和B，由于A中有一部分子树的结构和B是一
    

    • 

  • mongoDB 备份与恢复
开窍的石头
mongDB备份与恢复

    Mongodb导出与导入
1: 导入/导出可以操作的是本地的mongodb服务器,也可以是远程的.
所以,都有如下通用选项:
-h host   主机
--port port    端口
-u username 用户名
-p passwd   密码
2: mongoexport 导出json格式的文件 
    

    • 

  • [网络与通讯]椭圆轨道计算的一些问题
comsci
网络

    
     如果按照中国古代农历的历法，现在应该是某个季节的开始，但是由于农历历法是3000年前的天文观测数据，如果按照现在的天文学记录来进行修正的话，这个季节已经过去一段时间了。。。。。
      也就是说，还要再等3000年。才有机会了，太阳系的行星的椭圆轨道受到外来天体的干扰，轨道次序发生了变
    

    • 

  • 软件专利如何申请
cuiyadll
软件专利申请

    软件技术可以申请软件著作权以保护软件源代码，也可以申请发明专利以保护软件流程中的步骤执行方式。专利保护的是软件解决问题的思想，而软件著作权保护的是软件代码（即软件思想的表达形式）。例如，离线传送文件，那发明专利保护是如何实现离线传送文件。基于相同的软件思想，但实现离线传送的程序代码有千千万万种，每种代码都可以享有各自的软件著作权。申请一个软件发明专利的代理费大概需要5000-8000申请发明专利可
    

    • 

  • Android学习笔记
darrenzhu
android

    1.启动一个AVD
2.命令行运行adb shell可连接到AVD,这也就是命令行客户端
3.如何启动一个程序
  am start -n package name/.activityName
  am start -n com.example.helloworld/.MainActivity
启动Android设置工具的命令如下所示：
# am start -
    

    • 

  • apache虚拟机配置，本地多域名访问本地网站
dcj3sjt126com
apache

    现在假定你有两个目录，一个存在于 /htdocs/a，另一个存在于 /htdocs/b 。
现在你想要在本地测试的时候访问 www.freeman.com 对应的目录是 /xampp/htdocs/freeman ,访问 www.duchengjiu.com 对应的目录是 /htdocs/duchengjiu。
1、首先修改C盘WINDOWS\system32\drivers\etc目录下的 
    

    • 

  • yii2 restful web服务[速率限制]
dcj3sjt126com
PHPyii2

    速率限制
为防止滥用，你应该考虑增加速率限制到您的API。 例如，您可以限制每个用户的API的使用是在10分钟内最多100次的API调用。 如果一个用户同一个时间段内太多的请求被接收， 将返回响应状态代码 429 (这意味着过多的请求)。
要启用速率限制, [[yii\web\User::identityClass|user identity class]] 应该实现 [[yii\filter
    

    • 

  • Hadoop2.5.2安装——单机模式
eksliang
hadoophadoop单机部署

    转载请出自出处：http://eksliang.iteye.com/blog/2185414 一、概述
       Hadoop有三种模式 单机模式、伪分布模式和完全分布模式，这里先简单介绍单机模式 ，默认情况下，Hadoop被配置成一个非分布式模式，独立运行JAVA进程，适合开始做调试工作。
  二、下载地址
Hadoop 网址http:
    

    • 

  • LoadMoreListView+SwipeRefreshLayout（分页下拉）基本结构
gundumw100
android

    一切为了快速迭代
import java.util.ArrayList;
import org.json.JSONObject;
import android.animation.ObjectAnimator;
import android.os.Bundle;
import android.support.v4.widget.SwipeRefreshLayo
    

    • 

  • 三道简单的前端HTML/CSS题目
ini
htmlWeb前端css题目

    使用CSS为多个网页进行相同风格的布局和外观设置时，为了方便对这些网页进行修改，最好使用（ ）。http://hovertree.com/shortanswer/bjae/7bd72acca3206862.htm
 
在HTML中加入<table style=”color:red; font-size:10pt”>，此为（ ）。http://hovertree.com/s
    

    • 

  • overrided方法编译错误
kane_xie
override

    
问题描述：
在实现类中的某一或某几个Override方法发生编译错误如下：
Name clash: The method put(String) of type XXXServiceImpl has the same erasure as put(String) of type XXXService but does not override it
 
当去掉@Over
    

    • 

  • Java中使用代理IP获取网址内容（防IP被封，做数据爬虫）
mcj8089
免费代理IP代理IP数据爬虫JAVA设置代理IP爬虫封IP

    推荐两个代理IP网站：
 
1. 全网代理IP：http://proxy.goubanjia.com/
 
2. 敲代码免费IP：http://ip.qiaodm.com/
 
Java语言有两种方式使用代理IP访问网址并获取内容，
 
方式一，设置System系统属性
 
// 设置代理IP
System.getProper
    

    • 

  • Nodejs Express 报错之 listen EADDRINUSE
qiaolevip
每天进步一点点学习永无止境nodejs纵观千象

    当你启动 nodejs服务报错：
>node app
Express server listening on port 80
events.js:85
throw er; // Unhandled 'error' event
^
Error: listen EADDRINUSE
at exports._errnoException (
    

    • 

  • C++中三种new的用法
_荆棘鸟_
C++new

    转载自：http://news.ccidnet.com/art/32855/20100713/2114025_1.html
作者: mt
其一是new operator，也叫new表达式；其二是operator new，也叫new操作符。这两个英文名称起的也太绝了，很容易搞混，那就记中文名称吧。new表达式比较常见，也最常用，例如：
string* ps = new string("
    

    • 

  • Ruby深入研究笔记1
wudixiaotie
Ruby

    module是可以定义private方法的
module MTest
def aaa
puts "aaa"
private_method
end
private
def private_method
puts "this is private_method"
end
end

    

    •