Shulou(Shulou.com)06/01 Report--

Question 1

After the release of an application, it begins to report that the database connection pool is not enough. The log is as follows:

Com.alibaba.druid.pool.GetConnectionTimeoutException: wait millis 60000, active 500, maxActive 500, creating 0

Obviously, this is because the database connection pool is full, and it was in the business trough at that time, so it is obvious that it is not caused by sudden traffic. Another possibility is caused by long transactions, which are usually mixed with external network calls. Finally, together with the business person in charge, the possibility of long transactions is ruled out.

What else is possible?

The framework does bring us great convenience, sinking some repetitive work in the business into the framework, improving the efficiency of research and development, it is no exaggeration to say that some people do not know how to write code without Spring,MyBatis,SpringMvc.

What could that be? I came up with an idea: is it possible that some functional frameworks cannot support it, so the developer bypasses the implementation of the framework itself, resulting in no release of the connection? after I told the business manager about this idea, he said, "it's possible that this function needs to get the database name, so I got it through the Connection object." at this point, the answer may have come out, let's take a look at this code:

Public String getSchema (String tablename, boolean cached) throws Exception {return this.getJdbcTemplate (tablename). GetDataSource (). GetConnection (). GetCatalog ();}

Public T query (PreparedStatementCreator psc, @ Nullable final PreparedStatementSetter pss, final ResultSetExtractor rse) throws DataAccessException {Assert.notNull (rse, "ResultSetExtractor must not be null"); this.logger.debug ("Executing prepared SQL query"); return this.execute (psc, new PreparedStatementCallback () {@ Nullable public T doInPreparedStatement (PreparedStatement ps) throws SQLException {ResultSet rs = null; Object var3 Try {if (pss! = null) {pss.setValues (ps);} rs = ps.executeQuery (); var3 = rse.extractData (rs);} finally {JdbcUtils.closeResultSet (rs) If (pss instanceof ParameterDisposer) {((ParameterDisposer) pss) .cleanupParameters ();}} return var3;}});} public T execute (PreparedStatementCreator psc, PreparedStatementCallback action) throws DataAccessException {Assert.notNull (psc, "PreparedStatementCreator must not be null") Assert.notNull (action, "Callback object must not be null"); if (this.logger.isDebugEnabled ()) {String sql = getSql (psc); this.logger.debug ("Executing prepared SQL statement" + (sql! = null? "[" + sql + "]": "));} Connection con = DataSourceUtils.getConnection (this.obtainDataSource ()); PreparedStatement ps = null Object var13; try {ps = psc.createPreparedStatement (con); this.applyStatementSettings (ps); T result = action.doInPreparedStatement (ps); this.handleWarnings ((Statement) ps); var13 = result;} catch (SQLException var10) {if (psc instanceof ParameterDisposer) {(ParameterDisposer) psc). CleanupParameters () } String sql = getSql (psc); psc = null; JdbcUtils.closeStatement (ps); ps = null; DataSourceUtils.releaseConnection (con, this.getDataSource ()); con = null; throw this.translateException ("PreparedStatementCallback", sql, var10) } finally {if (psc instanceof ParameterDisposer) {((ParameterDisposer) psc). CleanupParameters ();} JdbcUtils.closeStatement (ps); DataSourceUtils.releaseConnection (con, this.getDataSource ());} return var13;}

The query method is implemented based on the template method execute, and finally is used inside the execute to ensure the release of the connection.

DataSourceUtils.releaseConnection, so there will be no problem of connection exhaustion. The problem is clear and the modification is simple. There are probably several ways to do this:

1. The closed connection shown here is simple and straightforward with the help of jdk's try resource statement.

Public String getSchema (String tablename, boolean cached) throws Exception {try (Connection connection = this.getJdbcTemplate (tablename). GetDataSource (). GetConnection ()) {return connection.getCatalog ();}}

two。 With the help of the template method design idea of JdbcTemplate, it provides an execute method. Users can get the Connection object as long as they implement the interface ConnectionCallback, execute the logic of getting the database name internally, and finally close the connection by finally.

/ * * Execute a JDBC data access operation, implemented as callback action * working on a JDBC Connection. This allows for implementing arbitrary * data access operations, within Spring's managed JDBC environment: * that is, participating in Spring-managed transactions and converting * JDBC SQLExceptions into Spring's DataAccessException hierarchy. *

The callback action can return a result object, for example a domain * object or a collection of domain objects. } catch (SQLException var8) {String sql = getSql (action); DataSourceUtils.releaseConnection (con, this.getDataSource ()); con = null; throw this.translateException ("ConnectionCallback", sql, var8);} finally {DataSourceUtils.releaseConnection (con, this.getDataSource ());} return var10 } jdbcTemplate.execute (new ConnectionCallback () {@ Override public Object doInConnection (Connection connection) throws SQLException, DataAccessException {return connection.getCatalog ();}})

Although both can solve the problem, I prefer the second approach, because this design idea, which is more in line with the framework, continues to leave some repetitive logic to the framework to implement, which also reflects a very important feature of the framework. Is to provide extensions to users.

Question 2

A few days ago, I wrote an intercept function of Spring AOP, and found that I couldn't get into the interception logic. I was puzzled by the fact that there was no problem with the expression. I finally calmed down and gradually troubleshooting.

The first obvious mistake was that the intercepted object was not managed by Spring, so the object was immediately handed over to Spring management, and the problem was still unsolved, and I began to recall the principle of proxy.

Spring proxy provides two implementation methods, one is jdk dynamic proxy, the other is cglib proxy. These two methods are suitable for situations where the proxy class implements the interface and the proxy class does not implement the interface. The internal idea is to generate a Proxy object based on a certain specification (interface or parent class). When the Proxy object method is called, the invoke method of InvocationHandler is called first, and the proxy logic is executed inside the invoke method. Then execute the real logic of the proxied object. A source file of the Proxy object generated by the jdk dynamic proxy is posted here for everyone to read:

Public class ProxyTest {/ * * defines the target interface, which contains a hello method (which is actually a specification) * / public interface ProxyT {void hello ();} / * * implementation class, which implements the ProxyT interface * / public static class ProxyTImpl implements ProxyT {@ Override public void hello () {System.out.println ("aaaa") }} public static void main (String [] args) {/ / set the source file System.getProperties () .put ("sun.misc.ProxyGenerator.saveGeneratedFiles", "true") that generates the Proxy object ProxyT proxyT1 = (ProxyT) Proxy.newProxyInstance (ProxyT.class.getClassLoader (), new Class [] {ProxyT.class}, new InvocationHandler () {@ Override public Object invoke (Object proxy, Method method, Object [] args) throws Throwable {System.out.println ("invoke"); return method.invoke (proxyT,args);}}); proxyT1.hello () }}

The resulting Proxy source file is as follows:

Package com.sun.proxy;import coding4fun.ProxyTest.ProxyT;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.lang.reflect.UndeclaredThrowableException / * * the generated proxy source code inherits the Proxy class of jdk and implements the ProxyT interface (in fact, it also explains why the dynamic proxy of jdk can only be implemented based on the interface, not on the parent class, because Proxy must inherit the Proxy of jdk, and java is a single inheritance, so Proxy can only be generated based on the specification of the interface) * / public final class $Proxy0 extends Proxy implements ProxyT {private static Method M1; private static Method m3; private static Method m2; private static Method M0 Public $Proxy0 (InvocationHandler var1) throws {super (var1);} public final boolean equals (Object var1) throws {try {return (Boolean) super.h.invoke (this, M1, new Object [] {var1});} catch (RuntimeException | Error var3) {throw var3;} catch (Throwable var4) {throw new UndeclaredThrowableException (var4) }} / / the hello method transfers the call to InvocationHandler public final void hello () throws {try {super.h.invoke (this, m3, (Object []) null);} catch (RuntimeException | Error var2) {throw var2;} catch (Throwable var3) {throw new UndeclaredThrowableException (var3) } public final String toString () throws {try {return (String) super.h.invoke (this, m2, (Object []) null);} catch (RuntimeException | Error var2) {throw var2;} catch (Throwable var3) {throw new UndeclaredThrowableException (var3) } public final int hashCode () throws {try {return (Integer) super.h.invoke (this, M0, (Object []) null);} catch (RuntimeException | Error var2) {throw var2;} catch (Throwable var3) {throw new UndeclaredThrowableException (var3) }} static {try {M1 = Class.forName ("java.lang.Object"). GetMethod ("equals", Class.forName ("java.lang.Object")); m3 = Class.forName ("coding4fun.ProxyTest$ProxyT"). GetMethod ("hello"); m2 = Class.forName ("java.lang.Object"). GetMethod ("toString") M0 = Class.forName ("java.lang.Object"). GetMethod ("hashCode");} catch (NoSuchMethodException var2) {throw new NoSuchMethodError (var2.getMessage ());} catch (ClassNotFoundException var3) {throw new NoClassDefFoundError (var3.getMessage ());}

As a matter of fact, I already have the answer here. There is a problem with the specification (interface or parent class) I gave to Spring. First of all, the class I want to proxy does not implement the interface, so the specification here is not the interface, but my class itself. According to the principle of cglib, it is to generate a Proxy class as the parent class, override the method to be proxied, and then add proxy logic. The problem is that the method of my class is static, and the static method cannot be rewritten, so there is no interception logic. Changing the static method to an instance method solves the problem. Here is a source file of the Proxy object generated by the cglib dynamic proxy for everyone to read:

Public class cglibtest {/ / defines the proxied class ProxyT, with an internal hello method public static class ProxyT {public void hello () {System.out.println ("aaaa") }} / / define a method interceptor similar to jdk's InvocationHandler public static class Interceptor implements MethodInterceptor {@ Override public Object intercept (Object o, Method method, Object [] objects, MethodProxy methodProxy) throws Throwable {/ / simple print System.out.println ("before invoke hello") / / execute the methods of the proxied class (hello) return methodProxy.invokeSuper (opaper objects);}} public static void main (String [] args) {/ / set the generation location of the CGLib proxy class System.setProperty (DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, ". / cg") / / set the output of the JDK proxy class System.getProperties (). Put ("sun.misc.ProxyGenerator.saveGeneratedFiles", "true"); MethodInterceptor methodInterceptor = new Interceptor (); Enhancer enhancer = new Enhancer (); / / set parent class enhancer.setSuperclass (ProxyT.class); / / set method callback enhancer.setCallback (methodInterceptor); ProxyT proxy = (ProxyT) enhancer.create () Proxy.hello ();}}

The resulting Proxy source file is as follows (some of the code has been removed, leaving only the logic of rewriting the hello method):

/ / inherit ProxyTpublic class cglibtest$ProxyT$$EnhancerByCGLIB$$8b3109a3 extends ProxyT implements Factory {final void CGLIB$hello$0 () {super.hello ();} / override hello method public final void hello () {/ / method interceptor MethodInterceptor var10000 = this.CGLIB$CALLBACK_0; if (var10000 = = null) {CGLIB$BIND_CALLBACKS (this); var10000 = this.CGLIB$CALLBACK_0 } if (var10000! = null) {/ / execute method interceptor var10000.intercept (this, CGLIB$hello$0$ Method, CGLIB$emptyArgs, CGLIB$hello$0$ Proxy);} else {super.hello () } the above is about the content of this article on "case Analysis of SpringCloud problems". I believe we all have a certain understanding. I hope the content shared by the editor will be helpful to you. If you want to know more about the relevant knowledge, please follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.