深入浅出设计模式（十）：15.迭代器模式（Iterator） 16.模版方法模式（TemplateMethod）

最新推荐文章于 2022-05-04 12:38:38 发布
最新推荐文章于 2022-05-04 12:38:38 发布
阅读量730 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 java 迭代器模式 模版方法模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuquan0071/article/details/50550390
版权

15.迭代器模式（Iterator）

在软件开发中，经常需要将某一类对象放在一个集合里，或者放在容器里，这个时候通常需要对集合或容器里的对象进行访问，很明显，对集合或容器里对象的访问必须涉及遍历，这就是迭代器模式。

哪里会用到迭代器模式

在电子商城的网站开发中，经常会有一个产品的列表展示，经常会使用到循环进行处理，从而将产品一个一个地展示出来。在网站浏览新闻时，各种类型的新闻也是一条一条显示在界面上的，这种类型的展示都需要使用迭代器。

迭代器模式的实现原理

迭代器模式就是提供了一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部标识，迭代器模式分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可以让外部代码透明地访问集合内部的数据。

这里写图片描述

迭代器模式在Java中的具体实现原理

Iterator

package java.util;

public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove();
}

Map

package java.util;

public interface Map<K, V> {

    int size();

    boolean isEmpty();

    boolean containsKey(Object key);

    boolean containsValue(Object value);

    V get(Object key);

    V put(K key, V value);

    V remove(Object key);

    void putAll(Map<? extends K, ? extends V> m);

    void clear();

    Set<K> keySet();

    Collection<V> values();

    Set<Map.Entry<K, V>> entrySet();

    interface Entry<K, V> {

        K getKey();

        V getValue();

        V setValue(V value);

        boolean equals(Object o);

        int hashCode();
    }

    boolean equals(Object o);

    int hashCode();
}

Collection

package java.util;

public interface Collection<E> extends Iterable<E> {

    int size();

    boolean isEmpty();

    boolean contains(Object o);

    Iterator<E> iterator();

    Object[] toArray();

    <T> T[] toArray(T[] a);

    boolean add(E e);

    boolean remove(Object o);

    boolean containsAll(Collection<?> c);

    boolean addAll(Collection<? extends E> c);

    boolean removeAll(Collection<?> c);

    boolean retainAll(Collection<?> c);

    void clear();

    boolean equals(Object o);

    int hashCode();
}

List

package java.util;

public interface List<E> extends Collection<E> {

    int size();

    boolean isEmpty();

    boolean contains(Object o);

    Iterator<E> iterator();

    Object[] toArray();

    <T> T[] toArray(T[] a);

    boolean add(E e);

    boolean remove(Object o);

    boolean containsAll(Collection<?> c);

    boolean addAll(Collection<? extends E> c);

    boolean addAll(int index, Collection<? extends E> c);

    boolean removeAll(Collection<?> c);

    boolean retainAll(Collection<?> c);

    void clear();

    boolean equals(Object o);

    int hashCode();

    E get(int index);

    E set(int index, E element);

    void add(int index, E element);

    E remove(int index);

    int indexOf(Object o);

    int lastIndexOf(Object o);

    ListIterator<E> listIterator();

    ListIterator<E> listIterator(int index);

    List<E> subList(int fromIndex, int toIndex);
}

16.模版方法模式（TemplateMethod）

模版方法模式在程序开发中经常使用，目的就是定义一系列算法执行的顺序，而把具体算法的实现在子类中完成，在很多框架（比如Spring、JUnit）中都实现了模版方法模式。

哪里会使用到模版方法模式

比如新闻发布系统中，对于查看新闻的页面来说，该新闻的抬头、结尾都有一定的格式，变化的只是新闻的内容，通常情况下，开发人员会使用模版技术，将新闻的抬头和结尾都固定，只改变新闻的内容，这样能够极大提高开发效率。

再比如其后介绍的命令模式，它是将用户事先设定好的命令存储起来，然后在指定的时间里按照一定的顺序将命令取出来执行，可以看出，在实际的应用开发中，命令模式与职责链模式可以很好的结合起来，对于用户的命令，可以通过命令模式进行存储，然后通过职责链模式，再将命令按照一定的顺序进行执行。

拿前面策略模式的薪资例子为例（和策略模式很像，但模版模式规定了执行方法的顺序）：
这里写图片描述

模版方法模式的实现原理

这里写图片描述

模版方法模式在JUnit中的使用

源码比较简单，模版方法模式主要体现在TestCase类的runBare()方法

模版方法模式在Servlet中的使用

在HttpServlet中有几个重要的方法，一个是doPost()方法，一个是doGet()方法，还有一个是Service()方法。

Servlet是由WebLogic之类的Servlet容器来调用处理器请求的，Servlet定义了一个处理模版，实现Servlet只需继承Servlet并实现doGet、doPost等方法即可。

HttpServlet 

package javax.servlet.http;

import java.io.IOException;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.text.MessageFormat;
import java.util.Enumeration;
import java.util.ResourceBundle;
import javax.servlet.GenericServlet;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public abstract class HttpServlet extends GenericServlet implements
        Serializable {
    private static final String METHOD_DELETE = "DELETE";
    private static final String METHOD_HEAD = "HEAD";
    private static final String METHOD_GET = "GET";
    private static final String METHOD_OPTIONS = "OPTIONS";
    private static final String METHOD_POST = "POST";
    private static final String METHOD_PUT = "PUT";
    private static final String METHOD_TRACE = "TRACE";
    private static final String HEADER_IFMODSINCE = "If-Modified-Since";
    private static final String HEADER_LASTMOD = "Last-Modified";
    private static final String LSTRING_FILE = "javax.servlet.http.LocalStrings";
    private static ResourceBundle lStrings = ResourceBundle
            .getBundle("javax.servlet.http.LocalStrings");

    // doGet方法
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_get_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }
    }

    protected long getLastModified(HttpServletRequest req) {
        return -1L;
    }

    // doHead方法
    protected void doHead(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        NoBodyResponse response = new NoBodyResponse(resp);

        doGet(req, response);
        response.setContentLength();
    }

    // doPost方法
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_post_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }
    }

    // doPut方法
    protected void doPut(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_put_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }
    }

    // doDelete方法
    protected void doDelete(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_delete_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }
    }

    private static Method[] getAllDeclaredMethods(Class c) {
        if (c.equals(HttpServlet.class)) {
            return null;
        }
        Method[] parentMethods = getAllDeclaredMethods(c.getSuperclass());
        Method[] thisMethods = c.getDeclaredMethods();
        if ((parentMethods != null) && (parentMethods.length > 0)) {
            Method[] allMethods = new Method[parentMethods.length
                    + thisMethods.length];

            System.arraycopy(parentMethods, 0, allMethods, 0,
                    parentMethods.length);

            System.arraycopy(thisMethods, 0, allMethods, parentMethods.length,
                    thisMethods.length);

            thisMethods = allMethods;
        }
        return thisMethods;
    }

    // doOptions方法
    protected void doOptions(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        Method[] methods = getAllDeclaredMethods(getClass());

        boolean ALLOW_GET = false;
        boolean ALLOW_HEAD = false;
        boolean ALLOW_POST = false;
        boolean ALLOW_PUT = false;
        boolean ALLOW_DELETE = false;
        boolean ALLOW_TRACE = true;
        boolean ALLOW_OPTIONS = true;
        for (int i = 0; i < methods.length; i++) {
            Method m = methods[i];
            if (m.getName().equals("doGet")) {
                ALLOW_GET = true;
                ALLOW_HEAD = true;
            }
            if (m.getName().equals("doPost")) {
                ALLOW_POST = true;
            }
            if (m.getName().equals("doPut")) {
                ALLOW_PUT = true;
            }
            if (m.getName().equals("doDelete")) {
                ALLOW_DELETE = true;
            }
        }
        String allow = null;
        if ((ALLOW_GET) && (allow == null)) {
            allow = "GET";
        }
        if (ALLOW_HEAD) {
            if (allow == null) {
                allow = "HEAD";
            } else {
                allow = allow + ", HEAD";
            }
        }
        if (ALLOW_POST) {
            if (allow == null) {
                allow = "POST";
            } else {
                allow = allow + ", POST";
            }
        }
        if (ALLOW_PUT) {
            if (allow == null) {
                allow = "PUT";
            } else {
                allow = allow + ", PUT";
            }
        }
        if (ALLOW_DELETE) {
            if (allow == null) {
                allow = "DELETE";
            } else {
                allow = allow + ", DELETE";
            }
        }
        if (ALLOW_TRACE) {
            if (allow == null) {
                allow = "TRACE";
            } else {
                allow = allow + ", TRACE";
            }
        }
        if (ALLOW_OPTIONS) {
            if (allow == null) {
                allow = "OPTIONS";
            } else {
                allow = allow + ", OPTIONS";
            }
        }
        resp.setHeader("Allow", allow);
    }

    // 执行doTrace
    protected void doTrace(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        String CRLF = "\r\n";
        String responseString = "TRACE " + req.getRequestURI() + " "
                + req.getProtocol();

        Enumeration reqHeaderEnum = req.getHeaderNames();
        while (reqHeaderEnum.hasMoreElements()) {
            String headerName = (String) reqHeaderEnum.nextElement();
            responseString = responseString + CRLF + headerName + ": "
                    + req.getHeader(headerName);
        }
        responseString = responseString + CRLF;
        // 获取长度
        int responseLength = responseString.length();
        // 设定报头
        resp.setContentType("message/http");
        resp.setContentLength(responseLength);
        ServletOutputStream out = resp.getOutputStream();
        out.print(responseString);
        out.close();
    }

    // 在service里判断具体执行哪个方法
    protected void service(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        String method = req.getMethod();
        if (method.equals("GET")) {
            long lastModified = getLastModified(req);
            if (lastModified == -1L) {
                doGet(req, resp);
            } else {
                long ifModifiedSince = req.getDateHeader("If-Modified-Since");
                if (ifModifiedSince < lastModified / 1000L * 1000L) {
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(304);
                }
            }
        } else if (method.equals("HEAD")) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);
        } else if (method.equals("POST")) {
            doPost(req, resp);
        } else if (method.equals("PUT")) {
            doPut(req, resp);
        } else if (method.equals("DELETE")) {
            doDelete(req, resp);
        } else if (method.equals("OPTIONS")) {
            doOptions(req, resp);
        } else if (method.equals("TRACE")) {
            doTrace(req, resp);
        } else {
            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);

            resp.sendError(501, errMsg);
        }
    }

    // 记录最后的修改状态
    private void maybeSetLastModified(HttpServletResponse resp,
            long lastModified) {
        if (resp.containsHeader("Last-Modified")) {
            return;
        }
        if (lastModified >= 0L) {
            resp.setDateHeader("Last-Modified", lastModified);
        }
    }

    // 都会执行service方法
    public void service(ServletRequest req, ServletResponse res)
            throws ServletException, IOException {
        try {
            HttpServletRequest request = (HttpServletRequest) req;
            response = (HttpServletResponse) res;
        } catch (ClassCastException e) {
            HttpServletResponse response;
            throw new ServletException("non-HTTP request or response");
        }
        HttpServletResponse response;
        HttpServletRequest request;
        service(request, response);
    }
}

模版方法模式在数据库的实际应用

注：以下Spring源码是Spring 3.2.16的，现在已经弃用了，不过可以看看了解一下模式

JpaTemplate 

package org.springframework.orm.jpa;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.PersistenceException;
import javax.persistence.Query;
import org.apache.commons.logging.Log;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.InvalidDataAccessApiUsageException;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;

@Deprecated
public class JpaTemplate extends JpaAccessor implements JpaOperations {
    private boolean exposeNativeEntityManager = false;

    public JpaTemplate() {
    }

    public JpaTemplate(EntityManagerFactory emf) {
        setEntityManagerFactory(emf);
        afterPropertiesSet();
    }

    public JpaTemplate(EntityManager em) {
        setEntityManager(em);
        afterPropertiesSet();
    }

    public void setExposeNativeEntityManager(boolean exposeNativeEntityManager) {
        this.exposeNativeEntityManager = exposeNativeEntityManager;
    }

    public boolean isExposeNativeEntityManager() {
        return this.exposeNativeEntityManager;
    }

    // 用于实现查询方法的回调
    public <T> T execute(JpaCallback<T> action) throws DataAccessException {
        return execute(action, isExposeNativeEntityManager());
    }

    // 查询方法
    public List executeFind(JpaCallback<?> action) throws DataAccessException {
        Object result = execute(action, isExposeNativeEntityManager());
        if (!(result instanceof List)) {
            throw new InvalidDataAccessApiUsageException(
                    "Result object returned from JpaCallback isn't a List: ["
                            + result + "]");
        }
        return (List) result;
    }

    // 执行回调
    public <T> T execute(JpaCallback<T> action,
            boolean exposeNativeEntityManager) throws DataAccessException {
        Assert.notNull(action, "Callback object must not be null");
        // 获取实体管理器
        EntityManager em = getEntityManager();
        boolean isNewEm = false;
        if (em == null) {
            em = getTransactionalEntityManager();
            if (em == null) {
                this.logger
                        .debug("Creating new EntityManager for JpaTemplate execution");
                em = createEntityManager();
                isNewEm = true;
            }
        }
        // 反射
        try {
            EntityManager emToExpose = exposeNativeEntityManager ? em
                    : createEntityManagerProxy(em);
            T result = action.doInJpa(emToExpose);
            flushIfNecessary(em, !isNewEm);
            return result;
        } catch (RuntimeException ex) {
            throw translateIfNecessary(ex);
        } finally {
            if (isNewEm) {
                this.logger
                        .debug("Closing new EntityManager after JPA template execution");
                EntityManagerFactoryUtils.closeEntityManager(em);
            }
        }
    }

    // 创建实体管理器的代理
    protected EntityManager createEntityManagerProxy(EntityManager em) {
        Class[] ifcs = null;
        EntityManagerFactory emf = getEntityManagerFactory();
        if ((emf instanceof EntityManagerFactoryInfo)) {
            Class entityManagerInterface = ((EntityManagerFactoryInfo) emf)
                    .getEntityManagerInterface();
            if (entityManagerInterface != null) {
                ifcs = new Class[] { entityManagerInterface };
            }
        }
        if (ifcs == null) {
            ifcs = ClassUtils.getAllInterfacesForClass(em.getClass());
        }
        return (EntityManager) Proxy.newProxyInstance(em.getClass()
                .getClassLoader(), ifcs, new CloseSuppressingInvocationHandler(
                em));
    }

    // 查询方法的具体实现
    public <T> T find(final Class<T> entityClass, final Object id)
            throws DataAccessException {
        execute(new JpaCallback() {
            public T doInJpa(EntityManager em) throws PersistenceException {
                return em.find(entityClass, id);
            }
        }, true);
    }

    // 查询方法
    public <T> T getReference(final Class<T> entityClass, final Object id)
            throws DataAccessException {
        execute(new JpaCallback() {
            public T doInJpa(EntityManager em) throws PersistenceException {
                return em.getReference(entityClass, id);
            }
        }, true);
    }

    public boolean contains(final Object entity) throws DataAccessException {
        ((Boolean) execute(new JpaCallback() {
            public Boolean doInJpa(EntityManager em)
                    throws PersistenceException {
                return Boolean.valueOf(em.contains(entity));
            }
        }, true)).booleanValue();
    }

    // 刷新方法的具体实现
    public void refresh(final Object entity) throws DataAccessException {
        execute(new JpaCallback() {
            public Object doInJpa(EntityManager em) throws PersistenceException {
                em.refresh(entity);
                return null;
            }
        }, true);
    }

    // 保存方法的具体实现
    public void persist(final Object entity) throws DataAccessException {
        execute(new JpaCallback() {
            public Object doInJpa(EntityManager em) throws PersistenceException {
                em.persist(entity);
                return null;
            }
        }, true);
    }

    // 更新方法的具体实现
    public <T> T merge(final T entity) throws DataAccessException {
        execute(new JpaCallback() {
            public T doInJpa(EntityManager em) throws PersistenceException {
                return em.merge(entity);
            }
        }, true);
    }

    // 删除方法的具体实现
    public void remove(final Object entity) throws DataAccessException {
        execute(new JpaCallback() {
            public Object doInJpa(EntityManager em) throws PersistenceException {
                em.remove(entity);
                return null;
            }
        }, true);
    }

    public void flush() throws DataAccessException {
        execute(new JpaCallback() {
            public Object doInJpa(EntityManager em) throws PersistenceException {
                em.flush();
                return null;
            }
        }, true);
    }

    // 查询方法
    public List find(String queryString) throws DataAccessException {
        return find(queryString, (Object[]) null);
    }

    // 返回多笔查询结果
    public List find(final String queryString, final Object... values) throws DataAccessException
    {
        (List)execute(new JpaCallback()
        {
            public List doInJpa(EntityManager em) throws PersistenceException
            {
                Query queryObject = em.createQuery(queryString);
                JpaTemplate.this.prepareQuery(queryObject);
                if (values != null) {
                    for (int i = 0; i < values.length; i++) {
                        queryObject.setParameter(i + 1, values[i]);
                    }
                }
                return queryObject.getResultList();
            }
        });
    }

    // 根据名称和实体类查询
    public List findByNamedParams(final String queryString, final Map<String, ?> params)
    throws DataAccessException
  {
    (List)execute(new JpaCallback()
    {
      public List doInJpa(EntityManager em)
        throws PersistenceException
      {
        Query queryObject = em.createQuery(queryString);
        JpaTemplate.this.prepareQuery(queryObject);
        if (params != null) {
          for (Map.Entry<String, ?> entry : params.entrySet()) {
            queryObject.setParameter((String)entry.getKey(), entry.getValue());
          }
        }
        return queryObject.getResultList();
      }
    });
  }

    public List findByNamedQuery(String queryName) throws DataAccessException {
        return findByNamedQuery(queryName, (Object[]) null);
    }

    public List findByNamedQuery(final String queryName, final Object... values)
    throws DataAccessException
  {
    (List)execute(new JpaCallback()
    {
      public List doInJpa(EntityManager em)
        throws PersistenceException
      {
        Query queryObject = em.createNamedQuery(queryName);
        JpaTemplate.this.prepareQuery(queryObject);
        if (values != null) {
          for (int i = 0; i < values.length; i++) {
            queryObject.setParameter(i + 1, values[i]);
          }
        }
        return queryObject.getResultList();
      }
    });
  }

    public List findByNamedQueryAndNamedParams(final String queryName, final Map<String, ?> params)
    throws DataAccessException
  {
    (List)execute(new JpaCallback()
    {
      public List doInJpa(EntityManager em)
        throws PersistenceException
      {
        Query queryObject = em.createNamedQuery(queryName);
        JpaTemplate.this.prepareQuery(queryObject);
        if (params != null) {
          for (Map.Entry<String, ?> entry : params.entrySet()) {
            queryObject.setParameter((String)entry.getKey(), entry.getValue());
          }
        }
        return queryObject.getResultList();
      }
    });
  }

    public void prepareQuery(Query query) {
        EntityManagerFactory emf = getEntityManagerFactory();
        if (emf != null) {
            EntityManagerFactoryUtils.applyTransactionTimeout(query,
                    getEntityManagerFactory());
        }
    }

    private class CloseSuppressingInvocationHandler implements
            InvocationHandler {
        private final EntityManager target;

        public CloseSuppressingInvocationHandler(EntityManager target) {
            this.target = target;
        }

        // java反射的具体应用
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            if (method.getName().equals("equals")) {
                return Boolean.valueOf(proxy == args[0]);
            }
            if (method.getName().equals("hashCode")) {
                return Integer.valueOf(System.identityHashCode(proxy));
            }
            if (method.getName().equals("close")) {
                return null;
            }
            try {
                Object retVal = method.invoke(this.target, args);
                if ((retVal instanceof Query)) {
                    JpaTemplate.this.prepareQuery((Query) retVal);
                }
                return retVal;
            } catch (InvocationTargetException ex) {
                throw ex.getTargetException();
            }
        }
    }
}

JdoTemplate 

package org.springframework.orm.jdo;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;
import java.util.Map;
import javax.jdo.JDOException;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.Query;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.InvalidDataAccessApiUsageException;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;

@Deprecated
public class JdoTemplate extends JdoAccessor implements JdoOperations {
    private boolean allowCreate = true;
    private boolean exposeNativePersistenceManager = false;

    public JdoTemplate() {
    }

    public JdoTemplate(PersistenceManagerFactory pmf) {
        setPersistenceManagerFactory(pmf);
        afterPropertiesSet();
    }

    public JdoTemplate(PersistenceManagerFactory pmf, boolean allowCreate) {
        setPersistenceManagerFactory(pmf);
        setAllowCreate(allowCreate);
        afterPropertiesSet();
    }

    public void setAllowCreate(boolean allowCreate) {
        this.allowCreate = allowCreate;
    }

    public boolean isAllowCreate() {
        return this.allowCreate;
    }

    public void setExposeNativePersistenceManager(
            boolean exposeNativePersistenceManager) {
        this.exposeNativePersistenceManager = exposeNativePersistenceManager;
    }

    public boolean isExposeNativePersistenceManager() {
        return this.exposeNativePersistenceManager;
    }

    public <T> T execute(JdoCallback<T> action) throws DataAccessException {
        return execute(action, isExposeNativePersistenceManager());
    }

    public Collection executeFind(JdoCallback<?> action)
            throws DataAccessException {
        Object result = execute(action, isExposeNativePersistenceManager());
        if ((result != null) && (!(result instanceof Collection))) {
            throw new InvalidDataAccessApiUsageException(
                    "Result object returned from JdoCallback isn't a Collection: ["
                            + result + "]");
        }
        return (Collection) result;
    }

    public <T> T execute(JdoCallback<T> action,
            boolean exposeNativePersistenceManager) throws DataAccessException {
        Assert.notNull(action, "Callback object must not be null");

        PersistenceManager pm = PersistenceManagerFactoryUtils
                .getPersistenceManager(getPersistenceManagerFactory(),
                        isAllowCreate());

        boolean existingTransaction = TransactionSynchronizationManager
                .hasResource(getPersistenceManagerFactory());
        try {
            PersistenceManager pmToExpose = exposeNativePersistenceManager ? pm
                    : createPersistenceManagerProxy(pm);
            T result = action.doInJdo(pmToExpose);
            flushIfNecessary(pm, existingTransaction);
            return postProcessResult(result, pm, existingTransaction);
        } catch (JDOException ex) {
            throw convertJdoAccessException(ex);
        } catch (RuntimeException ex) {
            throw ex;
        } finally {
            PersistenceManagerFactoryUtils.releasePersistenceManager(pm,
                    getPersistenceManagerFactory());
        }
    }

    protected PersistenceManager createPersistenceManagerProxy(
            PersistenceManager pm) {
        Class[] ifcs = ClassUtils.getAllInterfacesForClass(pm.getClass(),
                getClass().getClassLoader());
        return (PersistenceManager) Proxy.newProxyInstance(pm.getClass()
                .getClassLoader(), ifcs, new CloseSuppressingInvocationHandler(
                pm));
    }

    protected <T> T postProcessResult(T result, PersistenceManager pm,
            boolean existingTransaction) {
        return result;
    }

    public Object getObjectById(final Object objectId)
            throws DataAccessException {
        execute(new JdoCallback() {
            public Object doInJdo(PersistenceManager pm) throws JDOException {
                return pm.getObjectById(objectId, true);
            }
        }, true);
    }

    public <T> T getObjectById(final Class<T> entityClass, final Object idValue)
            throws DataAccessException {
        execute(new JdoCallback() {
            public T doInJdo(PersistenceManager pm) throws JDOException {
                return pm.getObjectById(entityClass, idValue);
            }
        }, true);
    }

    public void evict(final Object entity) throws DataAccessException {
        execute(new JdoCallback() {
            public Object doInJdo(PersistenceManager pm) throws JDOException {
                pm.evict(entity);
                return null;
            }
        }, true);
    }

    public void evictAll(final Collection entities) throws DataAccessException {
        execute(new JdoCallback() {
            public Object doInJdo(PersistenceManager pm) throws JDOException {
                pm.evictAll(entities);
                return null;
            }
        }, true);
    }

    public void evictAll() throws DataAccessException {
        execute(new JdoCallback() {
            public Object doInJdo(PersistenceManager pm) throws JDOException {
                pm.evictAll();
                return null;
            }
        }, true);
    }

    public void refresh(final Object entity) throws DataAccessException {
        execute(new JdoCallback() {
            public Object doInJdo(PersistenceManager pm) throws JDOException {
                pm.refresh(entity);
                return null;
            }
        }, true);
    }

    public void refreshAll(final Collection entities)
            throws DataAccessException {
        execute(new JdoCallback() {
            public Object doInJdo(PersistenceManager pm) throws JDOException {
                pm.refreshAll(entities);
                return null;
            }
        }, true);
    }

    public void refreshAll() throws DataAccessException {
        execute(new JdoCallback() {
            public Object doInJdo(PersistenceManager pm) throws JDOException {
                pm.refreshAll();
                return null;
            }
        }, true);
    }

    public <T> T makePersistent(final T entity) throws DataAccessException {
        execute(new JdoCallback() {
            public T doInJdo(PersistenceManager pm) throws JDOException {
                return pm.makePersistent(entity);
            }
        }, true);
    }

    public <T> Collection<T> makePersistentAll(final Collection<T> entities)
    throws DataAccessException
  {
    (Collection)execute(new JdoCallback()
    {
      public Collection<T> doInJdo(PersistenceManager pm)
        throws JDOException
      {
        return pm.makePersistentAll(entities);
      }
    }, true);
  }

    public void deletePersistent(final Object entity)
            throws DataAccessException {
        execute(new JdoCallback() {
            public Object doInJdo(PersistenceManager pm) throws JDOException {
                pm.deletePersistent(entity);
                return null;
            }
        }, true);
    }

    public void deletePersistentAll(final Collection entities)
            throws DataAccessException {
        execute(new JdoCallback() {
            public Object doInJdo(PersistenceManager pm) throws JDOException {
                pm.deletePersistentAll(entities);
                return null;
            }
        }, true);
    }

    public <T> T detachCopy(final T entity) {
        execute(new JdoCallback() {
            public T doInJdo(PersistenceManager pm) throws JDOException {
                return pm.detachCopy(entity);
            }
        }, true);
    }

    public <T> Collection<T> detachCopyAll(final Collection<T> entities)
  {
    (Collection)execute(new JdoCallback()
    {
      public Collection<T> doInJdo(PersistenceManager pm)
        throws JDOException
      {
        return pm.detachCopyAll(entities);
      }
    }, true);
  }

    public void flush() throws DataAccessException {
        execute(new JdoCallback() {
            public Object doInJdo(PersistenceManager pm) throws JDOException {
                pm.flush();
                return null;
            }
        }, true);
    }

    public <T> Collection<T> find(Class<T> entityClass)
            throws DataAccessException {
        return find(entityClass, null, null);
    }

    public <T> Collection<T> find(Class<T> entityClass, String filter)
            throws DataAccessException {
        return find(entityClass, filter, null);
    }

    public <T> Collection<T> find(final Class<T> entityClass, final String filter, final String ordering)
    throws DataAccessException
  {
    (Collection)execute(new JdoCallback()
    {
      public Collection<T> doInJdo(PersistenceManager pm)
        throws JDOException
      {
        Query query = filter != null ? pm.newQuery(entityClass, filter) : pm.newQuery(entityClass);
        JdoTemplate.this.prepareQuery(query);
        if (ordering != null) {
          query.setOrdering(ordering);
        }
        return (Collection)query.execute();
      }
    }, true);
  }

    public <T> Collection<T> find(Class<T> entityClass, String filter,
            String parameters, Object... values) throws DataAccessException {
        return find(entityClass, filter, parameters, values, null);
    }

    public <T> Collection<T> find(final Class<T> entityClass, final String filter, final String parameters, final Object[] values, final String ordering)
    throws DataAccessException
  {
    (Collection)execute(new JdoCallback()
    {
      public Collection<T> doInJdo(PersistenceManager pm)
        throws JDOException
      {
        Query query = pm.newQuery(entityClass, filter);
        JdoTemplate.this.prepareQuery(query);
        query.declareParameters(parameters);
        if (ordering != null) {
          query.setOrdering(ordering);
        }
        return (Collection)query.executeWithArray(values);
      }
    }, true);
  }

    public <T> Collection<T> find(Class<T> entityClass, String filter,
            String parameters, Map<String, ?> values)
            throws DataAccessException {
        return find(entityClass, filter, parameters, values, null);
    }

    public <T> Collection<T> find(final Class<T> entityClass, final String filter, final String parameters, final Map<String, ?> values, final String ordering)
    throws DataAccessException
  {
    (Collection)execute(new JdoCallback()
    {
      public Collection<T> doInJdo(PersistenceManager pm)
        throws JDOException
      {
        Query query = pm.newQuery(entityClass, filter);
        JdoTemplate.this.prepareQuery(query);
        query.declareParameters(parameters);
        if (ordering != null) {
          query.setOrdering(ordering);
        }
        return (Collection)query.executeWithMap(values);
      }
    }, true);
  }

    public Collection find(final String language, final Object queryObject)
    throws DataAccessException
  {
    (Collection)execute(new JdoCallback()
    {
      public Collection doInJdo(PersistenceManager pm)
        throws JDOException
      {
        Query query = pm.newQuery(language, queryObject);
        JdoTemplate.this.prepareQuery(query);
        return (Collection)query.execute();
      }
    }, true);
  }

    public Collection find(final String queryString)
    throws DataAccessException
  {
    (Collection)execute(new JdoCallback()
    {
      public Collection doInJdo(PersistenceManager pm)
        throws JDOException
      {
        Query query = pm.newQuery(queryString);
        JdoTemplate.this.prepareQuery(query);
        return (Collection)query.execute();
      }
    }, true);
  }

    public Collection find(final String queryString, final Object... values)
    throws DataAccessException
  {
    (Collection)execute(new JdoCallback()
    {
      public Collection doInJdo(PersistenceManager pm)
        throws JDOException
      {
        Query query = pm.newQuery(queryString);
        JdoTemplate.this.prepareQuery(query);
        return (Collection)query.executeWithArray(values);
      }
    }, true);
  }

    public Collection find(final String queryString, final Map<String, ?> values)
    throws DataAccessException
  {
    (Collection)execute(new JdoCallback()
    {
      public Collection doInJdo(PersistenceManager pm)
        throws JDOException
      {
        Query query = pm.newQuery(queryString);
        JdoTemplate.this.prepareQuery(query);
        return (Collection)query.executeWithMap(values);
      }
    }, true);
  }

    public <T> Collection<T> findByNamedQuery(final Class<T> entityClass, final String queryName)
    throws DataAccessException
  {
    (Collection)execute(new JdoCallback()
    {
      public Collection<T> doInJdo(PersistenceManager pm)
        throws JDOException
      {
        Query query = pm.newNamedQuery(entityClass, queryName);
        JdoTemplate.this.prepareQuery(query);
        return (Collection)query.execute();
      }
    }, true);
  }

    public <T> Collection<T> findByNamedQuery(final Class<T> entityClass, final String queryName, final Object... values)
    throws DataAccessException
  {
    (Collection)execute(new JdoCallback()
    {
      public Collection<T> doInJdo(PersistenceManager pm)
        throws JDOException
      {
        Query query = pm.newNamedQuery(entityClass, queryName);
        JdoTemplate.this.prepareQuery(query);
        return (Collection)query.executeWithArray(values);
      }
    }, true);
  }

    public <T> Collection<T> findByNamedQuery(final Class<T> entityClass, final String queryName, final Map<String, ?> values)
    throws DataAccessException
  {
    (Collection)execute(new JdoCallback()
    {
      public Collection<T> doInJdo(PersistenceManager pm)
        throws JDOException
      {
        Query query = pm.newNamedQuery(entityClass, queryName);
        JdoTemplate.this.prepareQuery(query);
        return (Collection)query.executeWithMap(values);
      }
    }, true);
  }

    public void prepareQuery(Query query) throws JDOException {
        PersistenceManagerFactoryUtils.applyTransactionTimeout(query,
                getPersistenceManagerFactory(), getJdoDialect());
    }

    private class CloseSuppressingInvocationHandler implements
            InvocationHandler {
        private final PersistenceManager target;

        public CloseSuppressingInvocationHandler(PersistenceManager target) {
            this.target = target;
        }

        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            if (method.getName().equals("equals")) {
                return Boolean.valueOf(proxy == args[0]);
            }
            if (method.getName().equals("hashCode")) {
                return Integer.valueOf(System.identityHashCode(proxy));
            }
            if (method.getName().equals("close")) {
                return null;
            }
            try {
                Object retVal = method.invoke(this.target, args);
                if ((retVal instanceof Query)) {
                    JdoTemplate.this.prepareQuery((Query) retVal);
                }
                return retVal;
            } catch (InvocationTargetException ex) {
                throw ex.getTargetException();
            }
        }
    }
}

SqlMapClientTemplate 

package org.springframework.orm.ibatis;

import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapExecutor;
import com.ibatis.sqlmap.client.event.RowHandler;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.JdbcUpdateAffectedIncorrectNumberOfRowsException;
import org.springframework.jdbc.support.JdbcAccessor;

@Deprecated
public class SqlMapClientTemplate extends JdbcAccessor implements
        SqlMapClientOperations {
    private SqlMapClient sqlMapClient;

    public SqlMapClientTemplate() {
    }

    public SqlMapClientTemplate(SqlMapClient sqlMapClient) {
        setSqlMapClient(sqlMapClient);
        afterPropertiesSet();
    }

    public SqlMapClientTemplate(DataSource dataSource, SqlMapClient sqlMapClient) {
        setDataSource(dataSource);
        setSqlMapClient(sqlMapClient);
        afterPropertiesSet();
    }

    public void setSqlMapClient(SqlMapClient sqlMapClient) {
        this.sqlMapClient = sqlMapClient;
    }

    public SqlMapClient getSqlMapClient() {
        return this.sqlMapClient;
    }

    public DataSource getDataSource() {
        DataSource ds = super.getDataSource();
        return ds != null ? ds : this.sqlMapClient.getDataSource();
    }

    public void afterPropertiesSet() {
        if (this.sqlMapClient == null) {
            throw new IllegalArgumentException(
                    "Property 'sqlMapClient' is required");
        }
        super.afterPropertiesSet();
    }

    /* Error */
    public <T> T execute(SqlMapClientCallback<T> action)
            throws DataAccessException {

    }

    @Deprecated
    public List executeWithListResult(SqlMapClientCallback<List> action)
            throws DataAccessException {
        return (List) execute(action);
    }

    @Deprecated
    public Map executeWithMapResult(SqlMapClientCallback<Map> action)
            throws DataAccessException {
        return (Map) execute(action);
    }

    public Object queryForObject(String statementName)
            throws DataAccessException {
        return queryForObject(statementName, null);
    }

    public Object queryForObject(final String statementName,
            final Object parameterObject) throws DataAccessException {
        execute(new SqlMapClientCallback() {
            public Object doInSqlMapClient(SqlMapExecutor executor)
                    throws SQLException {
                return executor.queryForObject(statementName, parameterObject);
            }
        });
    }

    public Object queryForObject(final String statementName,
            final Object parameterObject, final Object resultObject)
            throws DataAccessException {
        execute(new SqlMapClientCallback() {
            public Object doInSqlMapClient(SqlMapExecutor executor)
                    throws SQLException {
                return executor.queryForObject(statementName, parameterObject,
                        resultObject);
            }
        });
    }

    public List queryForList(String statementName) throws DataAccessException {
        return queryForList(statementName, null);
    }

    public List queryForList(final String statementName, final Object parameterObject)
    throws DataAccessException
  {
    (List)execute(new SqlMapClientCallback()
    {
      public List doInSqlMapClient(SqlMapExecutor executor)
        throws SQLException
      {
        return executor.queryForList(statementName, parameterObject);
      }
    });
  }

    public List queryForList(String statementName, int skipResults,
            int maxResults) throws DataAccessException {
        return queryForList(statementName, null, skipResults, maxResults);
    }

    public List queryForList(final String statementName, final Object parameterObject, final int skipResults, final int maxResults)
    throws DataAccessException
  {
    (List)execute(new SqlMapClientCallback()
    {
      public List doInSqlMapClient(SqlMapExecutor executor)
        throws SQLException
      {
        return executor.queryForList(statementName, parameterObject, skipResults, maxResults);
      }
    });
  }

    public void queryWithRowHandler(String statementName, RowHandler rowHandler)
            throws DataAccessException {
        queryWithRowHandler(statementName, null, rowHandler);
    }

    public void queryWithRowHandler(final String statementName,
            final Object parameterObject, final RowHandler rowHandler)
            throws DataAccessException {
        execute(new SqlMapClientCallback() {
            public Object doInSqlMapClient(SqlMapExecutor executor)
                    throws SQLException {
                executor.queryWithRowHandler(statementName, parameterObject,
                        rowHandler);
                return null;
            }
        });
    }

    public Map queryForMap(final String statementName, final Object parameterObject, final String keyProperty)
    throws DataAccessException
  {
    (Map)execute(new SqlMapClientCallback()
    {
      public Map doInSqlMapClient(SqlMapExecutor executor)
        throws SQLException
      {
        return executor.queryForMap(statementName, parameterObject, keyProperty);
      }
    });
  }

    public Map queryForMap(final String statementName, final Object parameterObject, final String keyProperty, final String valueProperty)
    throws DataAccessException
  {
    (Map)execute(new SqlMapClientCallback()
    {
      public Map doInSqlMapClient(SqlMapExecutor executor)
        throws SQLException
      {
        return executor.queryForMap(statementName, parameterObject, keyProperty, valueProperty);
      }
    });
  }

    public Object insert(String statementName) throws DataAccessException {
        return insert(statementName, null);
    }

    public Object insert(final String statementName,
            final Object parameterObject) throws DataAccessException {
        execute(new SqlMapClientCallback() {
            public Object doInSqlMapClient(SqlMapExecutor executor)
                    throws SQLException {
                return executor.insert(statementName, parameterObject);
            }
        });
    }

    public int update(String statementName) throws DataAccessException {
        return update(statementName, null);
    }

    public int update(final String statementName, final Object parameterObject)
            throws DataAccessException {
        ((Integer) execute(new SqlMapClientCallback() {
            public Integer doInSqlMapClient(SqlMapExecutor executor)
                    throws SQLException {
                return Integer.valueOf(executor.update(statementName,
                        parameterObject));
            }
        })).intValue();
    }

    public void update(String statementName, Object parameterObject,
            int requiredRowsAffected) throws DataAccessException {
        int actualRowsAffected = update(statementName, parameterObject);
        if (actualRowsAffected != requiredRowsAffected) {
            throw new JdbcUpdateAffectedIncorrectNumberOfRowsException(
                    statementName, requiredRowsAffected, actualRowsAffected);
        }
    }

    public int delete(String statementName) throws DataAccessException {
        return delete(statementName, null);
    }

    public int delete(final String statementName, final Object parameterObject)
            throws DataAccessException {
        ((Integer) execute(new SqlMapClientCallback() {
            public Integer doInSqlMapClient(SqlMapExecutor executor)
                    throws SQLException {
                return Integer.valueOf(executor.delete(statementName,
                        parameterObject));
            }
        })).intValue();
    }

    public void delete(String statementName, Object parameterObject,
            int requiredRowsAffected) throws DataAccessException {
        int actualRowsAffected = delete(statementName, parameterObject);
        if (actualRowsAffected != requiredRowsAffected) {
            throw new JdbcUpdateAffectedIncorrectNumberOfRowsException(
                    statementName, requiredRowsAffected, actualRowsAffected);
        }
    }
}
ToughMind_
关注
专栏目录
【c++设计模式18】行为模式3：迭代器模式（Iterator Pattern）
junxuezheng的博客
06-17 735
迭代器模式定义了一个迭代器接口（Iterator），该接口包含了对容器对象（如列表或集合）进行遍历的方法。具体容器对象（Concrete Collection）实现了迭代器接口，并且提供了创建迭代器对象的方法。迭代器对象（Iterator Object）封装了对容器对象的访问和遍历逻辑。
C++设计模式16：迭代器模式
琅嬛福地
04-28 1251
迭代器模式是一种行为型设计模式，它允许你在不暴露集合底层表现形式（列表、栈和树等）的情况下遍历集合中所有的元素。迭代器模式通过提供一个迭代器来实现这一点，该迭代器用于跟踪集合中的当前元素，并知道如何遍历到下一个元素。在迭代器模式中，集合类通常会实现一个名为 iterator 的方法，该方法返回一个迭代器对象。迭代器对象通常会实现两个方法：next 和 hasNext。next 方法返回集合中的下一个元素，而 hasNext 方法则用于检查是否还有更多的元素需要遍历。
CS61B - Iterator
dhjdjdjdj的博客
05-04 649
CS61B - Iterator Iterator是什么？ 看了CS61B这部分的网课两遍，感觉要好好记录下来，不然接下来还是容易忘。 首先，究竟是什么原因让我们揪出来了Iterator这个东西呢？我们先看一段代码： //assume we have an ArrayList called AList, which contains String type items //we want to create a method to print out all the items in the list pu
设计模式之Iterator
xwdreamer的专栏
10-28 3847
1参考文章 参考1：http://topic.csdn.net/u/20080722/16/e7fcffc3-3d54-48f6-9d3a-2cd39073a287.html 参考2：http://www.java63.com/design_pattern/iterator_pattern.html 参考3：http://blog.csdn.net/aaaaaaaa0705/articl
设计模式之模板模式（Template）与迭代器模式（Iterator）
logictime2的博客
04-21 437
我们首先来看模板模式(Template): 定义： 定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 核心思想： 父类定义骨架，子类实现某些细节。 使用场景： 1、有多个子类共有的方法，且逻辑相同。 2、重要的、复杂的方法，可以考虑作为模板方法。 注意事项： 为了防止子类重写父类的骨架方法，可以在父类中对骨架方法使用final。...
C++：从类模板 Iterator 中的模板参数来看迭代器
weixin_42307601的博客
08-16 1251
本篇博客主要从类模板 iterator 的模板参数来学习迭代器是如何拥有访问容器中的元素功能，并结合源码逐个对模板参数的意义进行分析不同类型的迭代器支持的一系列操作。希望这篇博客可以帮助读者从迭代器本质上去理解迭代器。
记一template 函数实现过程---std::iterator_traits在泛型算法中的应用
所有内容都已迁移到 https://huqijun.org
01-13 464
题目： 编写一个函数，接受表示未知类型迭代器的一对值，找出在序列中出现的最频繁的值 主要实现的是一个简单的统计出现次数的功能，不过template 使用过程中遇到一些问题 最初始版本： template T findMostValue(T tbegin,T tend) { std::map occur_times; for(T i = tbegin()
深入浅出Java 23种设计模式.rar
最新发布
03-20
本资料"深入浅出Java 23种设计模式"旨在帮助开发者理解和应用这23种经典设计模式。 首先，我们要了解设计模式的三大类别：创建型模式、结构型模式和行为型模式。创建型模式关注对象的创建过程，如单例模式...
《深入浅出设计模式》：创新学习，提升软件设计能力
Template Method模式（模板方法模式），定义了操作中的算法骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤；Iterator和Composite模式（迭代器模式和组合模式），...
深入浅出设计模式.rar
10-30
观察者模式（Observer）定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新，模板方法模式（Template Method）在一个抽象类中定义了一个操作中的算法骨架，而...
设计模式（二）之Strategy、Template and Iterator
W24的博客
04-15 292
二、Behavioral patterns(行为型模式)1.Strategy，策略模式在策略模式中，一个类的行为或算法可以在运行时更改。在策略模式中，我们创建表示各种模式的对象和一个行为随着策略对象改变而改变的 context对象，策略对象改变 context对象的执行算法。优点：算法可以自由切换、避免使用多重条件判断、扩展性良好。缺点：策略类会增多、所有策略类都需要对外暴露。解决方法：将这些算法...
函数模版重载之iterator_traits技巧
daidodo的专栏
12-06 1822
以下皆在MS  VS2005下测试运行。大家都知道在标准STL里的vector容器有这样2个构造函数：1）vector(size_type  sz,value_type  val);2）templatevector(InputIterator  first,InputIterator  last);其意义分别是：1）初始化一个大小为sz，所有元素值都为val的vector；2）由first
IOS深入学习（22）之Accessor method
Developer_Zhang的专栏
10-18 2287
1 前言     本章主要介绍了Objective-C中的存取方法的相关概念。 2 详述     存储方法是一个可以获得或者设置一个对象的属性值的实例方法。在Cocoa的术语中，一个检索对象属性值的方法提及为getter方法，或者"getter;"，一个改变对象属性值的方法提及为setter方法，或者“setter.”这些方法通常成对建立，提供获得或者设置对象属性值的API。      我
java redis 超时_java - Redis忙时读取超时异常 - 堆栈内存溢出
weixin_42439576的博客
02-21 853
我有一个用于事务数据获取并设置为Redis缓存的Spring Boot应用程序。 该应用程序每天的交易量为1000万。 我们的redis实例具有默认配置，并且没有哨兵，并且集群配置已禁用。 日常事务正在按预期方式进行和从redis获取。 我也有一个简单的rest控制器，用于删除数据并在持久化数据后重做。 当我在运行时调用此api时出现读取超时异常。 我正在使用jedis客户端连接到Re...
Servlet基本结构的源码解析
yuhongye110的专栏
08-30 429
如何写一个Servlet类？围绕这个问题，可以看一下Servlet的类结构。首先Servlet类也是一个Java类，只不过这个类比较特殊，它不能单独运行，必须要依托Servlet容器才能运行，Servlet类是一个组件，供Servlet引擎调用。既然是这样，那么Servlet类和Servlet引擎必然要遵循一套规范，以约束彼此的行为，遵循规范编写的Servlet类可以运行在任何符合规范的Servl...
不明怎觉厉(一）:servlet详解
u014035653的博客
09-14 400
一:定义:Java Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。二:三.servlet的任务:读取客户端（浏览器）发送的显式的数据。这包括网页上的 HTML 表单，或者也可以是来自 applet 或自定义的 HTTP 客户端程序的表单。 ● 读取客户端（浏览器）发送
在mybatis字段对应不上出现的小错误
说：/~不了的专栏
12-08 1万+
org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.reflection.ReflectionException: Could not set property 'printStyle' of 'class cn.itcast.jk.domain.Contract' with value
spring-data-redis 使用pipeline批量设置过期时间的bug
热门推荐
mhxy199288的专栏
10-24 1万+
redis没有批量设置过期时间的命令，所以当我们需要为多个key设置过期时间时，只能循环调用expire或pExpire命令为每个key设置过期时间，为了提高性能，我打算使用pipeline来批量操作，我使用的是spring-data-redis的stringRedisTemplate，版本为1.6.4-release，代码如下：final String[] keys = {"key1", "key
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值