import java.util.HashMap;
class Hello{
public void print(){
System.out.println("HelloWorld!");
}
}
public class SpringIoc {
public static HashMap<String,Object> contextmap=new HashMap<String,Object>();
/**
* 初始化一个bean放到spring容器中
*/
public static void initBean(Class<?> clazz){
try {
Object obj = clazz.newInstance();
contextmap.put(clazz.getSimpleName(), obj);
} catch (Exception e) {
}
}
/**
* 这是SpringIOC的核心方法
* 参考:http://www.tuicool.com/articles/qYfYJ3E
*/
public static void componentScan(String packagePath){
//扫描packagePath下的所有java文件及其子package，调用initBean()方法
}
public static void main(String[] args) {
initBean(Hello.class);
Hello he=(Hello) contextmap.get("Hello");
he.print();
}
}
package faicm.tools.util;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* @author faicm
*
*
* Sington.get(Person.class) will get sington new Person();
*
*
* if remove(Person.class) will get the other sington new Perso();
*
*/
@SuppressWarnings("rawtypes")
public class Singleton {
private static volatile HashMap<Class, Object> hashmap = new HashMap<Class, Object>();
private static ReentrantReadWriteLock rwlock = new ReentrantReadWriteLock();
private static Lock rlock = rwlock.readLock();
private static Lock wlock = rwlock.writeLock();
public static Object get(Class c) {
try {
rlock.lock();
if (hashmap.containsKey(c)) {
return hashmap.get(c);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
rlock.unlock();
}
synchronized (c) {
if (hashmap.containsKey(c)) {
return hashmap.get(c);
}
try {
Object o = c.newInstance();
hashmap.put(c, o);
return o;
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
}
}
}
public static void remove(Class c) {
try {
wlock.lock();
synchronized (c) {
hashmap.remove(c);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
wlock.unlock();
}
}
public static void save(Object c) {
try {
synchronized (c.getClass()) {
hashmap.put(c.getClass(), c);
}
} catch (Exception e) {
} finally {
}
}
public static void clear() {
Set<Class> set = hashmap.keySet();
Iterator<Class> i = set.iterator();
while (i.hasNext()) {
Class e = i.next();
remove(e);
}
hashmap = new HashMap<Class, Object>();
}
}
public class SingletonBuilder {
@SuppressWarnings("rawtypes")
private static final ConcurrentMap<Class, Singleton> map = new ConcurrentHashMap<>();
@SuppressWarnings("unchecked")
public static <E> Singleton<E> getSingleton(Class<E> type){
Singleton<E> s = map.get(type);
if(s==null){
synchronized (map) {
if((s = map.get(type))==null)
map.put(type, s=new Singleton<>());
}
}
return s;
}
public static class Singleton<E>{
ArrayList<E> list = new ArrayList<>();
private Singleton(){}
@SuppressWarnings("unchecked")
public E getData(){
return (E) "123";
}
public boolean add(E e){
return list.add(e);
}
public E get(int index){
return list.get(index);
}
}
public static void main(String[] args) {
Singleton<String> single = SingletonBuilder.getSingleton(String.class);
single.add("123");
single.add("456");
System.out.println(single.get(0));
Singleton<Integer> single1 = SingletonBuilder.getSingleton(Integer.class);
single1.add(1);
single1.add(2);
System.out.println(single1.get(0));
Singleton<String> single2 = SingletonBuilder.getSingleton(String.class);
single2.add("aa");
single2.add("bb");
System.out.println(single2.get(3));
}
}
public class Test {
public static <T> T getInstance(String qualifiedClassName) throws Exception {
Class clazz = Class.forName(qualifiedClassName);
return (T) clazz.newInstance();
}
public static void main(String[] args) throws Exception {
Foo foo = getInstance("Foo"); // 根据左值就能自动判断类型
foo.go();
Bar bar = getInstance("Bar"); // 根据左值就能自动判断类型
bar.go();
}
}
class Foo {
public void go() {
System.out.println("Foo.go()");
}
}
class Bar {
public void go() {
System.out.println("Bar.go()");
}
}Foo.go()
Bar.go()
