2019年第二季度笔记整理

package a;


import org.apache.log4j.Logger;
import org.hibernate.collection.spi.PersistentCollection;
import org.hibernate.proxy.HibernateProxy;
import org.hibernate.proxy.LazyInitializer;

import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;

public class HibernateProxyUtil {
    private static Logger log = Logger.getLogger(HibernateProxyUtil.class);
    private final HashMap<Object,Object> map=new HashMap<>();
    private static final Set<String> TYPES;
    static {
        TYPES = new HashSet<>();
        TYPES.addAll(Arrays.asList("java.lang.Integer",
                "java.lang.Double",
                "java.lang.Float",
                "java.lang.Long",
                "java.lang.Short",
                "java.lang.Byte",
                "java.lang.Boolean",
                "java.lang.Character",
                "java.lang.String"));
    }

    public Object getOwnClass(Object object){
        if(object==null)return object;
        forall(object);
        return object;
    }

    public void forall(Object object){
        if(object==null)return;
        if(map.containsKey(object)) {
            return;
        }

        map.put(object,object);

        Class t =object.getClass();
        Field[] fields=t.getDeclaredFields();
        for (Field field1 :fields){
            //设置字段可访问
            field1.setAccessible(true);
            try {
                //得到字段对应的值
                Object  obj = field1.get(object);

                if(obj==null)continue;
                //如果是基本类型
                if(obj.getClass().isPrimitive())continue;
                //如果是基本类型的包装类型
                if(TYPES.contains(obj.getClass().getName()))continue;

                if (obj instanceof HibernateProxy) {
                    //如果已经见过这个地址(循环引用)
                    if(map.containsKey(obj)){
                        field1.set(object,map.get(obj));
                    }else {
                        LazyInitializer initializer = ((HibernateProxy) obj).getHibernateLazyInitializer();
                        Object real = initializer.getImplementation();
                        map.put(obj,real);
                        field1.set(object,real);
                    }
                } else if (obj instanceof PersistentCollection) {
                    //这种情况还未解决
                    PersistentCollection collection = (PersistentCollection) obj;

                    //TODO
                    field1.set(object,null);
//                    if (!collection.wasInitialized())
//                        return null;
//                    Object val = collection.getValue();
//                    if (val == null)
//                        return null;
//                    o=val;
                }
                //递归当前对象的子属性
                forall(field1.get(object));


            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }
}

package util;
import java.io.IOException;
import java.io.InputStream;
import java.sql.DriverManager;
import java.util.Properties;
import org.apache.log4j.Logger;
import java.sql.Connection;
public class DBUtil {
	private static Logger log = Logger.getLogger(DBUtil.class);
	private static String driverClassName;
	private static String url;
	private static String username;
	private static String password;
	
	
	
	public static void syso(){
		System.out.println(driverClassName+"\r"
				+ url+"\r"
				+username+"\r"
				+password);
	}
	
	public static void init(){
		/*path 不以’/'开头时默认是从此类所在的包下取资源，
    	 * 以’/'开头则是从ClassPath根下获取。
    	 * 其只是通过path构造一个绝对路径，最终还是由ClassLoader获取资源。
    	 */
    	InputStream fiss = DBUtil.class.getResourceAsStream("/jdbc.properties");
		Properties prop = new Properties();  
		try {
			prop.load(fiss);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		driverClassName=prop.getProperty("driverClassName");
		url=prop.getProperty("url");
		username=prop.getProperty("username");
		password=prop.getProperty("password");
	}
	public static void main(String[] args) {
		Connection con=DBUtil.getConnection();
		System.out.println(con);
	}
	public static Connection getConnection() {
		DBUtil.init();
		Connection conn=null;
		try{
			Class.forName(driverClassName);
			conn=(Connection) DriverManager.getConnection(url,username,password);
			
		}catch(Exception e){
			e.printStackTrace();
			try {
				throw e;
			} catch (Exception e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
		}return conn;
	}
	public static void closeConnection(Connection conn) throws Exception{
		DBUtil.init();
		try {
			if(conn!=null){
				conn.close();
			}
		} catch (Exception e) {
			e.printStackTrace();
			throw e;
		}
	}
}

package jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.Vector;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.ScrollPaneConstants;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.DefaultTableModel;
/**
 * * @author ZhangLiang
 */
public class BookModel {
    public static void main(String[] args) {
        getTestJTable("select * from UserDoc");
    }
    public static void getTestJTable(String strSql) {
        JFrame f = new JFrame("Sql结果放入JTable");
        try {
            Connection conn = getConn();
            PreparedStatement ps = conn.prepareStatement(strSql);
            ResultSet rs = ps.executeQuery();
            ResultSetMetaData rsmd = rs.getMetaData();
            int rsmdCount = rsmd.getColumnCount();
            JTable table = new JTable(0, rsmdCount); //这里应该是根据那个列数定义，或者是，普及后，然后宽度定义。
            table.getTableHeader().setResizingAllowed(true);
            DefaultTableModel dataModel = (DefaultTableModel) table.getModel();
            DefaultTableCellRenderer r = new DefaultTableCellRenderer();
            r.setHorizontalAlignment(JLabel.CENTER);
            table.setDefaultRenderer(Object.class, r);
            int count = dataModel.getRowCount(); //这里的count是个0
            while (count > 0) {
                dataModel.removeRow(0);
            }
            while (rs.next()) {
                Vector<String> v = new Vector<String>();
                for (int i = 1; i <= rsmdCount; i++) {
                    v.add(rs.getString(i));
                }
                dataModel.addRow(v);
            }
            table.setModel(dataModel); //就差那个设置滚动条了。 //开始吧jtable放到那个jscroll中。
            table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF); //自动设置宽度
            table.setEnabled(false);
            JScrollPane scrollPane2 = new JScrollPane(table, ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED, ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
            scrollPane2.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
            scrollPane2.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
            f.add(scrollPane2);
            f.setSize(1024, 500);
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            f.setVisible(true);
        } catch (SQLException e) {
        }
    }
    public static Connection getConn() {
        String url = "jdbc:sqlserver://192.168.1.237:1433;DatabaseName=kh";
        String username = "sa";
        String password = "zl1110";
        Connection conn = null;
        try {
            Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
            conn = DriverManager.getConnection(url, username, password);
        } catch (ClassNotFoundException | SQLException ex) {
            System.out.println("ERROR:" + ex.getMessage());
        }
        return conn;
    }
}