javaee软件设计的基本原则

//首先，应当定义三层的接口，先是Dao层的接口
package dao;
public interface Dao {
	String getData(); 
} 

//然后是biz层的接口。需要注意的是，因为biz层要调用dao层的方法，因此在biz对象中，需要维护一个Dao对象的引用。
//为此，所有Biz层接口的实现类都应当有一个Dao类型的属性，并提供一个setDao方法。因此，在Biz接口中，我们定义了setDao方法
package biz；
import dao.Dao;
public interface Biz {
	void setDao(Dao dao);
	String dealData();
}

//最后是view层的接口。与之前的情况类似，view层也应当有一个Biz类型的引用，用以调用biz层的方法。
//因此，在view接口中我们定义了setBiz方法
package view;
import biz.Biz;
public interface View {
	void setBiz(Biz biz);
	void showData();
} 


//定义完了三个接口以后，接下来应该给出的是接口的实现类。例如，我们首先给出Dao接口的实现类。
//假设我们希望从当前目录下的"Test.txt"文件中获取数据，则可以给出一个实现类：FileDaoImpl实现Dao接口，代码如下：
package dao;
import java.io.*;
public class FileDaoImpl implements Dao {
	public String getData() {
		BufferedReader br = null;
		try {
			FileInputStream fin = new FileInputStream("Test.txt");
			br = new BufferedReader(fin);
			data = br.readLine();
		}
		catch (IOException e) {
			e.printStacktrace();
		} finally {
			if (br != null) {
				try {
					br.close();
				}
				catch(IOException e) {
					e.printStackTrace();
				}
			}
		}
		return data;
	}
}

//下面是Biz接口的实现。假设我们要实现把所有数据转换成大写的逻辑，则可以给出一个UpperCaseBizImpl的实现类，代码为
package biz;
import dao.Dao;
public class UpperCaseBizImpl implements Biz {
	private Dao dao;
	
	public String dealData() {
		String data = dao.getData();
		if (data != null) {
			data = data.toUpperCase();
		}
		return data;
	}
	
	public void setDao(Dao dao) {
		this.dao = dao;
	}
}

//最后，view接口的实现比较简单，我们给出TextViewImpl的实现代码：
package view;
import biz.BiZ;
public class TextViewImpl implements View {
	private Biz biz;
	
	public void setBiz(Biz biz) {
		this.biz = biz;
	}
	
	public void showData() {
		String data = biz.dealData();
		System.out.println(data);
	}
}



//把三个接口实现完成之后，接下来就可以写主方法，设置类之间的关联关系。代码如下：
package test;
import dao.*;
import biz.*;
import view.*;
public class TestMain {
	public static void main(String[] args) {
		//创建对象并调用set方法进行组装
		Dao dao = new FileDaoImpl();
		Biz biz = new LowerCaseBizImpl();
		biz.setDao(dao);
		View view = new TextViewImpl();
		view.setBiz(biz);
		
		view.showData();
	}
}

//首先，修改码的原因与创建对象相关。
//为此，我们可以利用简单工厂模式，把原有的创建对象的过程，都挪到一个简单工厂里面，工厂代码如下：
package factory;
import dao.*;
import biz.*;
import view.*;
public class SimpleFactory {
	public SimpleFactory() {
		//
	}

	public Dao createDao() {
		return new FileDaoImpl();
	}

	public Biz createBiz() {
		return new UpperCaseBizImpl();
	}

	pubblic View createView() {
		return new TextViewImpl();
	}
}

//这样,TestMain程序就可以改成
package test;
import dao.*;
import biz.*;
import view.*;
import factory.SimpleFactory;

public class TestMain {
    public static void main(String[] args) {
		SimpleFactory factory = new SimpleFactory();
		Dao dao = factory.createDao();
		Biz biz = factory.createBiz();
		biz.setDao(dao);
		View view = factory.createView();
		view.setBiz(biz);
		
		view.showData();
	}
}

//这样，当实现类改变的时候，主方法不需要改变，因为创建对象的代码都使用factory来完成了
//但是，这样如果需求改变的话，还是要该factory的代码。有没有办法不改代码，就能够在某个层次用一个实现类替换另一个实现类呢？
//我们知道，利用反射可以灵活的创建对象。使用Class.forName(String className)，通过一个字符串获得类对象。
//然后，通过类对象，可以创建一个相应类型的对象。简单的说，可以通过一个字符串，创建一个该类型的对象。而字符串，
//既可以写在代码中，同样可以从别的途径获得。例如，可以从一个配置文件中获得。
//因此，修改配置文件，就可以让class.forName获得不同的字符串，从而创建出不同类型的对象来。
//换句话说，我们可以通过配置文件+反射的方式，来完成对象的创建。
//这样，当我们需要修改实现类的时候，只需要修改配置文件，而完全不需要修改代码。

//为此，我们可以为SimpleFactory增加一个Properties的属性，并且在构造方法中，
//利用load方法，读入conf.props。完整的SimpleFactory代码如下：
package factory;
import dao.*;
import biz.*;
import view.*;
import java.util.Properties;
import java.io.*;
public class SimpleFactory {
	private Properties props;
	public SimpleFactory() {
		props = new Properties();
		InputStream is = null;
		try{
			   is = new FileInputStream("conf.props");
			   props.load(is);
		   }catch(IOException e){
			e.printStackTrace();
		}
		finally{
			if (is!=null){
				try{
					is.close();
				}
				catch(Exception e){
					e.printStackTrace();
				}
			}
		}
	}
	public Dao createDao(){
		String className = props.getProperty("dao");
		Dao dao = (Dao) createObject(className);
		return dao;
	}
	public Biz createBiz(){
		String className = props.getProperty("biz");
		Biz biz = (Biz) createObject(className);
		return biz;
	}

	public View createView(){
		String className = props.getProperty("view");
		View view = (View) createObject(className);
		return view;
	}
	private Object createObject(String name){
		Object result = null;
		try {
			Class c = Class.forName(name);
			result = c.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		} 
		return result;
	}
}

//配置conf,props文件如下：
view=view.TextViewImpl
biz=biz.UpperCaseBizImpl
dao=dao.FileDaoImpl

//test.txt文件内容如下：
Hello World


//当上述简单工厂完成之后，运行结果如下：
HELLO WORLD

//而当有新需求，希望把所有字符改成小写，只需要修改配置文件即可：
biz=biz.LowerCaseBizImpl