SSM项目脚手架

    <context:property-placeholder location="classpath:jdbc.properties,file:///external/jdbc_overwrite.properties" ignore-resource-not-found="true"/>

  <!--事务管理-->
  <tx:advice id="txAdvice" transaction-manager="transactionManager">
      <tx:attributes>
          <tx:method name="select*" read-only="true" />
          <tx:method name="find*" read-only="true" />
          <tx:method name="get*" read-only="true" />
          <tx:method name="*" />
      </tx:attributes>
  </tx:advice>
  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      <property name="dataSource" ref="dataSource" />
  </bean>

public class ReplicationDriver extends NonRegisteringReplicationDriver
		implements java.sql.Driver {
	static {
		try {
			java.sql.DriverManager
					.registerDriver(new NonRegisteringReplicationDriver());
		} catch (SQLException E) {
			throw new RuntimeException("Can't register driver!");
		}
	}

	public ReplicationDriver() throws SQLException {
		// Required for Class.forName().newInstance()
	}
}

public class NonRegisteringReplicationDriver extends NonRegisteringDriver {
	public NonRegisteringReplicationDriver() throws SQLException {
		super();
	}

	public Connection connect(String url, Properties info) throws SQLException {
		Properties parsedProps = parseURL(url, info);

		if (parsedProps == null) {
			return null;
		}

		Properties masterProps = (Properties)parsedProps.clone();
		Properties slavesProps = (Properties)parsedProps.clone();

		// Marker used for further testing later on, also when
		// debugging
		slavesProps.setProperty("com.mysql.jdbc.ReplicationConnection.isSlave", "true");

		String hostValues = parsedProps.getProperty(HOST_PROPERTY_KEY);

		if (hostValues != null) {
			StringTokenizer st = new StringTokenizer(hostValues, ",");

			StringBuffer masterHost = new StringBuffer();
			StringBuffer slaveHosts = new StringBuffer();

			if (st.hasMoreTokens()) {
				String[] hostPortPair = parseHostPortPair(st.nextToken());

				if (hostPortPair[HOST_NAME_INDEX] != null) {
					masterHost.append(hostPortPair[HOST_NAME_INDEX]);
				}

				if (hostPortPair[PORT_NUMBER_INDEX] != null) {
					masterHost.append(":");
					masterHost.append(hostPortPair[PORT_NUMBER_INDEX]);
				}
			}

			boolean firstSlaveHost = true;

			while (st.hasMoreTokens()) {
				String[] hostPortPair = parseHostPortPair(st.nextToken());

				if (!firstSlaveHost) {
					slaveHosts.append(",");
				} else {
					firstSlaveHost = false;
				}

				if (hostPortPair[HOST_NAME_INDEX] != null) {
					slaveHosts.append(hostPortPair[HOST_NAME_INDEX]);
				}

				if (hostPortPair[PORT_NUMBER_INDEX] != null) {
					slaveHosts.append(":");
					slaveHosts.append(hostPortPair[PORT_NUMBER_INDEX]);
				}
			}

			if (slaveHosts.length() == 0) {
				throw SQLError.createSQLException(
						"Must specify at least one slave host to connect to for master/slave replication load-balancing functionality",
						SQLError.SQL_STATE_INVALID_CONNECTION_ATTRIBUTE);
			}

			masterProps.setProperty(HOST_PROPERTY_KEY, masterHost.toString());
			slavesProps.setProperty(HOST_PROPERTY_KEY, slaveHosts.toString());
		}

		return new ReplicationConnection(masterProps, slavesProps);
	}
}

public ReplicationConnection(Properties masterProperties,
		Properties slaveProperties) throws SQLException {
	Driver driver = new Driver();

	StringBuffer masterUrl = new StringBuffer("jdbc:mysql://");
      StringBuffer slaveUrl = new StringBuffer("jdbc:mysql://");

      String masterHost = masterProperties
      	.getProperty(NonRegisteringDriver.HOST_PROPERTY_KEY);

      if (masterHost != null) {
      	masterUrl.append(masterHost);
      }

      String slaveHost = slaveProperties
      	.getProperty(NonRegisteringDriver.HOST_PROPERTY_KEY);

      if (slaveHost != null) {
      	slaveUrl.append(slaveHost);
      }

      String masterDb = masterProperties
      	.getProperty(NonRegisteringDriver.DBNAME_PROPERTY_KEY);

      masterUrl.append("/");

      if (masterDb != null) {
      	masterUrl.append(masterDb);
      }

      String slaveDb = slaveProperties
      	.getProperty(NonRegisteringDriver.DBNAME_PROPERTY_KEY);

      slaveUrl.append("/");

      if (slaveDb != null) {
      	slaveUrl.append(slaveDb);
      }

      this.masterConnection = (com.mysql.jdbc.Connection) driver.connect(
              masterUrl.toString(), masterProperties);
      this.slavesConnection = (com.mysql.jdbc.Connection) driver.connect(
              slaveUrl.toString(), slaveProperties);

	this.currentConnection = this.masterConnection;
}

public synchronized void setReadOnly(boolean readOnly) throws SQLException {
	if (readOnly) {
		if (currentConnection != slavesConnection) {
			switchToSlavesConnection();
		}
	} else {
		if (currentConnection != masterConnection) {
			switchToMasterConnection();
		}
	}
}
private synchronized void switchToMasterConnection() throws SQLException {
	swapConnections(this.masterConnection, this.slavesConnection);
}

private synchronized void switchToSlavesConnection() throws SQLException {
	swapConnections(this.slavesConnection, this.masterConnection);
}
private synchronized void swapConnections(Connection switchToConnection,
		Connection switchFromConnection) throws SQLException {
	String switchFromCatalog = switchFromConnection.getCatalog();
	String switchToCatalog = switchToConnection.getCatalog();

	if (switchToCatalog != null && !switchToCatalog.equals(switchFromCatalog)) {
		switchToConnection.setCatalog(switchFromCatalog);
	} else if (switchFromCatalog != null) {
		switchToConnection.setCatalog(switchFromCatalog);
	}

	boolean switchToAutoCommit = switchToConnection.getAutoCommit();
	boolean switchFromConnectionAutoCommit = switchFromConnection.getAutoCommit();

	if (switchFromConnectionAutoCommit != switchToAutoCommit) {
		switchToConnection.setAutoCommit(switchFromConnectionAutoCommit);
	}

	int switchToIsolation = switchToConnection
			.getTransactionIsolation();

	int switchFromIsolation = switchFromConnection.getTransactionIsolation();

	if (switchFromIsolation != switchToIsolation) {
		switchToConnection
				.setTransactionIsolation(switchFromIsolation);
	}

	this.currentConnection = switchToConnection;
}

public java.sql.Connection connect(String url, Properties info)
		throws SQLException {
	if (url != null) {
		if (StringUtils.startsWithIgnoreCase(url, LOADBALANCE_URL_PREFIX)) {
			return connectLoadBalanced(url, info);
		} else if (StringUtils.startsWithIgnoreCase(url,
				REPLICATION_URL_PREFIX)) {
			return connectReplicationConnection(url, info);
		}
	}

	Properties props = null;

	if ((props = parseURL(url, info)) == null) {
		return null;
	}

	try {
		Connection newConn = new com.mysql.jdbc.Connection(host(props),
				port(props), props, database(props), url);

		return newConn;
	} catch (SQLException sqlEx) {
		// Don't wrap SQLExceptions, throw
		// them un-changed.
		throw sqlEx;
	} catch (Exception ex) {
		throw SQLError.createSQLException(Messages
				.getString("NonRegisteringDriver.17") //$NON-NLS-1$
				+ ex.toString()
				+ Messages.getString("NonRegisteringDriver.18"), //$NON-NLS-1$
				SQLError.SQL_STATE_UNABLE_TO_CONNECT_TO_DATASOURCE);
	}
}

private static final String REPLICATION_URL_PREFIX = "jdbc:mysql:replication://";

private static final String URL_PREFIX = "jdbc:mysql://";

private static final String MXJ_URL_PREFIX = "jdbc:mysql:mxj://";

private static final String LOADBALANCE_URL_PREFIX = "jdbc:mysql:loadbalance://";

Connection(String hostToConnectTo, int portToConnectTo, Properties info,
			String databaseToConnectTo, String url)
			throws SQLException {
	this.charsetToNumBytesMap = new HashMap();

	this.connectionCreationTimeMillis = System.currentTimeMillis();
	this.pointOfOrigin = new Throwable();

	// Stash away for later, used to clone this connection for Statement.cancel
	// and Statement.setQueryTimeout().
	//

	this.origHostToConnectTo = hostToConnectTo;
	this.origPortToConnectTo = portToConnectTo;
	this.origDatabaseToConnectTo = databaseToConnectTo;

	try {
		Blob.class.getMethod("truncate", new Class[] {Long.TYPE});

		this.isRunningOnJDK13 = false;
	} catch (NoSuchMethodException nsme) {
		this.isRunningOnJDK13 = true;
	}

	this.sessionCalendar = new GregorianCalendar();
	this.utcCalendar = new GregorianCalendar();
	this.utcCalendar.setTimeZone(TimeZone.getTimeZone("GMT"));

	//
	// Normally, this code would be in initializeDriverProperties,
	// but we need to do this as early as possible, so we can start
	// logging to the 'correct' place as early as possible...this.log
	// points to 'NullLogger' for every connection at startup to avoid
	// NPEs and the overhead of checking for NULL at every logging call.
	//
	// We will reset this to the configured logger during properties
	// initialization.
	//
	this.log = LogFactory.getLogger(getLogger(), LOGGER_INSTANCE_NAME);

	// We store this per-connection, due to static synchronization
	// issues in Java's built-in TimeZone class...
	this.defaultTimeZone = Util.getDefaultTimeZone();

	if ("GMT".equalsIgnoreCase(this.defaultTimeZone.getID())) {
		this.isClientTzUTC = true;
	} else {
		this.isClientTzUTC = false;
	}

	this.openStatements = new HashMap();
	this.serverVariables = new HashMap();
	this.hostList = new ArrayList();

	if (hostToConnectTo == null) {
		this.host = "localhost";
		this.hostList.add(this.host);
	} else if (hostToConnectTo.indexOf(",") != -1) {
		// multiple hosts separated by commas (failover)
		StringTokenizer hostTokenizer = new StringTokenizer(
				hostToConnectTo, ",", false);

		while (hostTokenizer.hasMoreTokens()) {
			this.hostList.add(hostTokenizer.nextToken().trim());
		}
	} else {
		this.host = hostToConnectTo;
		this.hostList.add(this.host);
	}

	this.hostListSize = this.hostList.size();
	this.port = portToConnectTo;

	if (databaseToConnectTo == null) {
		databaseToConnectTo = "";
	}

	this.database = databaseToConnectTo;
	this.myURL = url;
	this.user = info.getProperty(NonRegisteringDriver.USER_PROPERTY_KEY);
	this.password = info
			.getProperty(NonRegisteringDriver.PASSWORD_PROPERTY_KEY);

	if ((this.user == null) || this.user.equals("")) {
		this.user = "";
	}

	if (this.password == null) {
		this.password = "";
	}

	this.props = info;
	initializeDriverProperties(info);

	try {
		createNewIO(false);
		this.dbmd = new DatabaseMetaData(this, this.database);
	} catch (SQLException ex) {
		cleanup(ex);

		// don't clobber SQL exceptions
		throw ex;
	} catch (Exception ex) {
		cleanup(ex);

		StringBuffer mesg = new StringBuffer();

		if (getParanoid()) {
			mesg.append("Cannot connect to MySQL server on ");
			mesg.append(this.host);
			mesg.append(":");
			mesg.append(this.port);
			mesg.append(".\n\n");
			mesg.append("Make sure that there is a MySQL server ");
			mesg.append("running on the machine/port you are trying ");
			mesg
					.append("to connect to and that the machine this software is "
							+ "running on ");
			mesg.append("is able to connect to this host/port "
					+ "(i.e. not firewalled). ");
			mesg
					.append("Also make sure that the server has not been started "
							+ "with the --skip-networking ");
			mesg.append("flag.\n\n");
		} else {
			mesg.append("Unable to connect to database.");
		}

		mesg.append("Underlying exception: \n\n");
		mesg.append(ex.getClass().getName());

		if (!getParanoid()) {
			mesg.append(Util.stackTraceToString(ex));
		}

		throw SQLError.createSQLException(mesg.toString(),
				SQLError.SQL_STATE_COMMUNICATION_LINK_FAILURE);
	}
}

if (getRoundRobinLoadBalance()) {
	hostIndex = getNextRoundRobinHostIndex(getURL(),
			this.hostList);
}

for (; hostIndex < this.hostListSize; hostIndex++) {

	if (hostIndex == 0) {
		this.hasTriedMasterFlag = true;
	}

	try {
		String newHostPortPair = (String) this.hostList
				.get(hostIndex);

		int newPort = 3306;

		String[] hostPortPair = NonRegisteringDriver
				.parseHostPortPair(newHostPortPair);
		String newHost = hostPortPair[NonRegisteringDriver.HOST_NAME_INDEX];

		if (newHost == null || newHost.trim().length() == 0) {
			newHost = "localhost";
		}

		if (hostPortPair[NonRegisteringDriver.PORT_NUMBER_INDEX] != null) {
			try {
				newPort = Integer
						.parseInt(hostPortPair[NonRegisteringDriver.PORT_NUMBER_INDEX]);
			} catch (NumberFormatException nfe) {
				throw SQLError.createSQLException(
						"Illegal connection port value '"
								+ hostPortPair[NonRegisteringDriver.PORT_NUMBER_INDEX]
								+ "'",
						SQLError.SQL_STATE_INVALID_CONNECTION_ATTRIBUTE);
			}
		}

		this.io = new MysqlIO(newHost, newPort, mergedProps,
				getSocketFactoryClassName(), this,
				getSocketTimeout());

		this.io.doHandshake(this.user, this.password,
				this.database);
		this.connectionId = this.io.getThreadId();
		this.isClosed = false;

		// save state from old connection
		boolean oldAutoCommit = getAutoCommit();
		int oldIsolationLevel = this.isolationLevel;
		boolean oldReadOnly = isReadOnly();
		String oldCatalog = getCatalog();

		// Server properties might be different
		// from previous connection, so initialize
		// again...
		initializePropsFromServer();

		if (isForReconnect) {
			// Restore state from old connection
			setAutoCommit(oldAutoCommit);

			if (this.hasIsolationLevels) {
				setTransactionIsolation(oldIsolationLevel);
			}

			setCatalog(oldCatalog);
		}

		if (hostIndex != 0) {
			setFailedOverState();
			queriesIssuedFailedOverCopy = 0;
		} else {
			this.failedOver = false;
			queriesIssuedFailedOverCopy = 0;

			if (this.hostListSize > 1) {
				setReadOnlyInternal(false);
			} else {
				setReadOnlyInternal(oldReadOnly);
			}
		}

		connectionGood = true;

		break; // low-level connection succeeded
	} catch (Exception EEE) {
		if (this.io != null) {
			this.io.forceClose();
		}

		connectionNotEstablishedBecause = EEE;

		connectionGood = false;

		if (EEE instanceof SQLException) {
			SQLException sqlEx = (SQLException)EEE;

			String sqlState = sqlEx.getSQLState();

			// If this isn't a communications failure, it will probably never succeed, so
			// give up right here and now ....
			if ((sqlState == null)
					|| !sqlState
							.equals(SQLError.SQL_STATE_COMMUNICATION_LINK_FAILURE)) {
				throw sqlEx;
			}
		}

		// Check next host, it might be up...
		if (getRoundRobinLoadBalance()) {
			hostIndex = getNextRoundRobinHostIndex(getURL(),
					this.hostList) - 1 /* incremented by for loop next time around */;
		} else if ((this.hostListSize - 1) == hostIndex) {
			throw new CommunicationsException(this,
					(this.io != null) ? this.io
							.getLastPacketSentTimeMs() : 0,
							EEE);
		}
	}
}