Mybatis学习（一）：基础概念和简单自定义持久层框架demo

一、一个简单自定义持久层框架demo

1.1 普通的JDBC连接数据库

public class Test {

    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            //加载数据库驱动
            Class.forName("com.mysql.jdbc.Driver");
            //通过驱动管理类获取连接
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis", "root", "root");
            //定义SQL语句，其中？表示占位符
            String sql = "select * from user where name = ?";
            preparedStatement = connection.prepareStatement(sql);
            //设置参数,参数是从1开始
            preparedStatement.setString(1, "zhangsan");
            //执行SQL查询数据库返回查询结果集
            resultSet = preparedStatement.executeQuery();
            //遍历查询结果集
            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                User user = new User();
                user.setId(id);
                user.setName(name);
                System.out.println(user);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (resultSet != null) {
                try {
                    resultSet.close();
                } catch (SQLException sqlException) {
                    sqlException.printStackTrace();
                }
            }
            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
            } catch (SQLException sqlException) {
                sqlException.printStackTrace();
            }
            try {
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException sqlException) {
                sqlException.printStackTrace();
            }

        }
    }
}

1.2 对jdbc存在的问题分析和解决

从上边1.1的手写JDBC连接可以看出：

1. 频繁创建和释放数据库连接，性能损失；
2. SQL语句是写死的，在实际项目中是会经常变化的；
3. preparedStatement传入参数时也有硬编码的存在，不易维护；
4. 从resultSet获取结果信息封装为Java某个对象时也存在硬编码问题；

我们可以用以下方法解决上述问题：

1. 采用连接池的方式避免频繁创建、释放数据库连接；
2. 对硬编码的问题我们可以用配置文件的方式去替代；
3. 用反射及内省方法完成resultSet结果集到Java对象的封装；

1.3 简单设计一个持久层框架

用户端：引入自定义框架的jar包。
（1）提供一个Mapper.xml存储关于SQL的配置信息文件；

>

    >
        select * from user
    >
>
 
  
namespace.id来组成statementId唯一标识SQL语句
 （2）提供一个MapperConfig.xml存储关于数据源等配置信息文件，引入Mapper.xml；
 
  
>
    <!-- 数据库配置信息 -->
    
    
    
    

    <!-- 引入mapper信息 -->
    
>
 
  
框架端：
 新建一个maven项目，引入相关依赖。
 
  
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.customize</groupId>
    <artifactId>customizeOrm</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
        <java.version>1.8</java.version>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.20</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.1.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>


    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>


</project>
 
  
 
   
加载配置文件
        配置文件以流的形式被读取出来，放在内存中不好操作，我们创建bean对象的方式来存储。
 (1) 创建Resources类，根据配置文件的路径，加载配置文件成字节输入流存在内存中。
 
  
 
  
import java.io.InputStream;

public class Resources {

    public static InputStream getResourcesAsStream(String path){
        return Resources.class.getResourceAsStream(path);
    }
}
 
  
(2) 创建Configuration对象存MapperConfig.xml解析到的内容；
 
  
package com.customer.config;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

public class Configuration {
    /**
     * 数据源信息
     */
    private DataSource dataSource;
    /**
     * mapper的相关信息
     */
    private Map<String,MappedStatement> map = new HashMap<>();

    public DataSource getDataSource() {
        return dataSource;
    }

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public Map<String, MappedStatement> getMap() {
        return map;
    }

    public void setMap(Map<String, MappedStatement> map) {
        this.map = map;
    }
}

 
  
(3) 创建MappedStatement对象存mapper.xml解析出来的sql信息、statement类型、输入参数类型、输出参数类型。
 
  
package com.customer.config;

public class MappedStatement {
    /**
     * id
     */
    private String id;
    /**
     * SQL语句
     */
    private String sql;
    /**
     * 输入参数
     */
    private Class<?> paramterType;
    /**
     * 输出参数
     */
    private Class<?> resultType;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getSql() {
        return sql;
    }

    public void setSql(String sql) {
        this.sql = sql;
    }

    public Class<?> getParamterType() {
        return paramterType;
    }

    public void setParamterType(Class<?> paramterType) {
        this.paramterType = paramterType;
    }

    public Class<?> getResultType() {
        return resultType;
    }

    public void setResultType(Class<?> resultType) {
        this.resultType = resultType;
    }
}

 
  
 
   
解析配置文件（dom4j的方式）
 （1）创建SqlSessionFactoryBuilder类：将解析出来的配置文件信息存在上边的容器对象中；创建SqlSessionFactory类，用来生产SqlSession对象（会话对象）
 
  
 
  
 
   
 创建XMLConfigerBuilder类解析config配置文件，并将解析结果注入Configuration中：
 
  
 
  
package com.customer.io;

import com.customer.config.Configuration;
import com.customer.config.Resources;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import javax.naming.NamingException;
import java.beans.PropertyVetoException;
import java.io.InputStream;
import java.util.List;
import java.util.Properties;

public class XMLConfigerBuilder {

    private Configuration configuration;

    public XMLConfigerBuilder(Configuration configuration) {
        this.configuration = configuration;
    }

    public Configuration parseConfiguration(InputStream inputStream) throws DocumentException, PropertyVetoException, NamingException, ClassNotFoundException {
        Document document = new SAXReader().read(inputStream);
        //取得标签
        Element rootElement = document.getRootElement();
        Properties properties = new Properties();
        List<Element> propertyNodes = rootElement.selectNodes("//property");
        for (Element propertyNode : propertyNodes) {
            String name = propertyNode.attributeValue("name");
            String value = propertyNode.attributeValue("value");
            properties.setProperty(name,value);
        }
        //连接池
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(properties.getProperty("driverClass"));
        dataSource.setJdbcUrl(properties.getProperty("jdbcUrl"));
        dataSource.setUser(properties.getProperty("user"));
        dataSource.setPassword(properties.getProperty("password"));
        //将连接池放入configuration对象中
        configuration.setDataSource(dataSource);

        //利用XMLMapperBuilder解析mapper
        List<Element> mapperNodes = rootElement.selectNodes("//mapper");
        XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(configuration);
        for (Element mapperElement : mapperNodes) {
            String path = mapperElement.attributeValue("resource");
            xmlMapperBuilder.parseMapper(Resources.getResourcesAsStream(path));
        }
        return configuration;
    }
}

 
  
 
   
 创建XMLMapperBuilder类解析mapper.xml文件，将解析到的信息封装到MappedStatement对象并注入Configuration中；
 
  
 
  
在这里插入代码片
 
  
 
   
创建SqlSessionFactory接口类及默认实现DefaultSqlSessionFactory，生产SqlSession对象。
 
  
 
  
package com.customer.io;

import com.customer.config.Configuration;
import com.customer.config.MappedStatement;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.InputStream;
import java.util.List;

public class XMLMapperBuilder {

    private Configuration configuration;

    public XMLMapperBuilder(Configuration configuration) {
        this.configuration = configuration;
    }

    public Configuration parseMapper(InputStream inputStream) throws DocumentException, ClassNotFoundException {
        Document document = new SAXReader().read(inputStream);
        Element rootElement = document.getRootElement();
        String namespace = rootElement.attributeValue("namespace");
        List<Element> selectElements = rootElement.selectNodes("select");
        for (Element selectElement : selectElements) {
            String id = selectElement.attributeValue("id");
            //入参类型
            String paramterType = selectElement.attributeValue("paramterType");
            //返回类型
            String resultType = selectElement.attributeValue("resultType");
            //sql语句
            String sql = selectElement.getTextTrim();
            //唯一标识 namespace+id
            String key = namespace + id;
            //将解析到的SQL信息封装到MappedStatement对象中
            MappedStatement mappedStatement = new MappedStatement();
            mappedStatement.setId(id);
            mappedStatement.setSql(sql);
            mappedStatement.setParamterType(getClassTypeByStr(paramterType));
            mappedStatement.setResultType(getClassTypeByStr(resultType));
            //将封装好的MappedStatement对象注入Configuration对象中
            configuration.getMap().put(key,mappedStatement);
        }
        return configuration;
    }

    private Class<?> getClassTypeByStr(String typeStr) throws ClassNotFoundException {
        return Class.forName(typeStr);
    }
}

 
  
 
   
 创建SqlSessionFactoryBuilder类生成SqlSessionFactory
 
  
 
  
package com.customer.sqlsession;

import com.customer.config.Configuration;
import com.customer.io.XMLConfigerBuilder;
import org.dom4j.DocumentException;

import javax.naming.NamingException;
import java.beans.PropertyVetoException;
import java.io.InputStream;

public class SqlSessionFactoryBuilder {

    private Configuration configuration;

    public SqlSessionFactoryBuilder() {
        configuration = new Configuration();
    }

    public SqlSessionFactory build(InputStream inputStream) throws ClassNotFoundException, PropertyVetoException,
            DocumentException, NamingException {
        //1.解析配置文件得到Configuration对象
        XMLConfigerBuilder xmlConfigerBuilder = new XMLConfigerBuilder(configuration);
        xmlConfigerBuilder.parseConfiguration(inputStream);
        //2.创建SqlSessionFactory
        return new DefaultSqlSessionFactory(configuration);
    }
}

 
  
 
   
 创建SqlSessionFactory接口和其默认实现类DefaultSqlSessionFactory，主要负责生产SqlSession
 
  
 
  
package com.customer.sqlsession;

public interface SqlSessionFactory {

    public SqlSession openSession();
}
 
  
package com.customer.sqlsession;

import com.customer.config.Configuration;

public class DefaultSqlSessionFactory implements SqlSessionFactory{

    private Configuration configuration;

    public DefaultSqlSessionFactory(Configuration configuration) {
        this.configuration = configuration;
    }

    @Override
    public SqlSession openSession() {
        return new DefaultSqlSession(configuration);
    }
}
 
  
 
   
创建SqlSession接口及其默认实现类DefaultSqlSession，定义对数据库的操作：查询、新增、修改、删除
 
  
 
  
 
   
 创建SqlSession接口，定义对数据库的操作：查询、新增、修改、删除
 
  
 
  
package com.customer.sqlsession;

import java.util.List;

public interface SqlSession {

    <E> List<E> selectList(String statementId, Object... param);

    <T> T selectOne(String statementId, Object... param);
}

 
  
 
   
 创建SqlSession接口的默认实现类DefaultSqlSession
 
  
 
  
package com.customer.sqlsession;

import com.customer.config.Configuration;
import com.customer.config.MappedStatement;
import com.customer.executor.Executor;
import com.customer.executor.SimpleExecutor;

import java.util.List;

public class DefaultSqlSession implements SqlSession {

    private Configuration configuration;

    public DefaultSqlSession(Configuration configuration) {
        this.configuration = configuration;
    }

    private Executor simpleExecutor = new SimpleExecutor();

    @Override
    public <E> List<E> selectList(String statementId, Object... param) {
        MappedStatement mappedStatement = configuration.getMap().get(statementId);
        return simpleExecutor.query(configuration, mappedStatement, param);
    }

    @Override
    public <T> T selectOne(String statementId, Object... param) {
        List<Object> objects = selectList(statementId, param);
        if (objects.size() > 1) {
            throw new RuntimeException("Too many returns !");
        }
        return (T) objects.get(0);
    }
}

 
  
 
   
创建Executor接口及其实现类SimpleExecutor，定义query()方法执行jdbc。
 
  
 
  
 
   
 创建Executor接口，定义query()方法
 
  
 
  
package com.customer.executor;

import com.customer.config.Configuration;
import com.customer.config.MappedStatement;

import java.util.List;

public interface Executor {
    <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object[] param);
}

 
  
 
   
 创建Executor接口的实现类SimpleExecutor
 
  
 
  
package com.customer.executor;

import com.customer.config.Configuration;
import com.customer.config.MappedStatement;
import com.customer.util.GenericTokenParser;
import com.customer.util.ParameterMapping;
import com.customer.util.ParameterMappingTokenHandler;

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class SimpleExecutor implements Executor {

    private Connection connection = null;

    @Override
    public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object[] param) throws SQLException, NoSuchFieldException, IllegalAccessException, InstantiationException, IntrospectionException, InvocationTargetException {
        //1.获取数据库连接
        connection = configuration.getDataSource().getConnection();
        //2.获取要执行的SQL语句
        String sql = mappedStatement.getSql();
        //3.对sql进行预编译处理
        BoundSql boundSql = getBoundSql(sql);
        //4.获取预编译对象PreparedStatement
        PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getParseSql());
        //5.设置参数对
        Class<?> paramterType = mappedStatement.getParamterType();
        List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
        for (int i = 0; i < parameterMappingList.size(); i++) {
            ParameterMapping parameterMapping = parameterMappingList.get(i);
            String content = parameterMapping.getContent();
            //利用反射
            Field declaredField = paramterType.getDeclaredField(content);
            declaredField.setAccessible(true);
            Object o = declaredField.get(param[0]);
            preparedStatement.setObject(i + 1, o);
        }
        //6.执行sql语句
        ResultSet resultSet = preparedStatement.executeQuery();
        //7.封装返回结果集
        Class<?> resultType = mappedStatement.getResultType();
        ArrayList<Object> list = new ArrayList();
        while (resultSet.next()) {
            Object o = resultType.newInstance();
            ResultSetMetaData metaData = resultSet.getMetaData();
            for (int i = 0; i < metaData.getColumnCount(); i++) {
                //字段名
                String columnName = metaData.getColumnName(i);
                Object object = resultSet.getObject(columnName);
                PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultType);
                Method writeMethod = propertyDescriptor.getWriteMethod();
                writeMethod.invoke(o, object);
            }
            list.add(o);
        }
        return (List<E>) list;
    }

    private BoundSql getBoundSql(String sql) {
        //标记处理类：配置标记解析器来完成对占位符的解析处理工作
        ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();
        GenericTokenParser genericTokenParser = new GenericTokenParser("#{", "}", parameterMappingTokenHandler);
        //解析得到的sql
        String parse = genericTokenParser.parse(sql);
        //#{}里面解析出来的参数名称
        List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();
        return new BoundSql(parse, parameterMappings);
    }
}

 
  
 
   
 引入预编译处理工具类
 
  
 
  
package com.customer.util;

public class ParameterMapping {

    private String content;

    public ParameterMapping(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

 
  
package com.customer.util;

/**
 * @author Clinton Begin
 */
public interface TokenHandler {
  String handleToken(String content);
}

 
  
package com.customer.util;

import java.util.ArrayList;
import java.util.List;




public class ParameterMappingTokenHandler implements TokenHandler {
	private List<ParameterMapping> parameterMappings = new ArrayList<ParameterMapping>();

	// context是参数名称 #{id} #{username}

	@Override
	public String handleToken(String content) {
		parameterMappings.add(buildParameterMapping(content));
		return "?";
	}

	private ParameterMapping buildParameterMapping(String content) {
		ParameterMapping parameterMapping = new ParameterMapping(content);
		return parameterMapping;
	}

	public List<ParameterMapping> getParameterMappings() {
		return parameterMappings;
	}

	public void setParameterMappings(List<ParameterMapping> parameterMappings) {
		this.parameterMappings = parameterMappings;
	}

}

 
  
/**
 *    Copyright 2009-2017 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package com.customer.util;

/**
 * @author Clinton Begin
 */
public class GenericTokenParser {

  private final String openToken; //开始标记
  private final String closeToken; //结束标记
  private final TokenHandler handler; //标记处理器

  public GenericTokenParser(String openToken, String closeToken, TokenHandler handler) {
    this.openToken = openToken;
    this.closeToken = closeToken;
    this.handler = handler;
  }

  /**
   * 解析${}和#{}
   * @param text
   * @return
   * 该方法主要实现了配置文件、脚本等片段中占位符的解析、处理工作，并返回最终需要的数据。
   * 其中，解析工作由该方法完成，处理工作是由处理器handler的handleToken()方法来实现
   */
  public String parse(String text) {
    // 验证参数问题，如果是null，就返回空字符串。
    if (text == null || text.isEmpty()) {
      return "";
    }

    // 下面继续验证是否包含开始标签，如果不包含，默认不是占位符，直接原样返回即可，否则继续执行。
    int start = text.indexOf(openToken, 0);
    if (start == -1) {
      return text;
    }

   // 把text转成字符数组src，并且定义默认偏移量offset=0、存储最终需要返回字符串的变量builder，
    // text变量中占位符对应的变量名expression。判断start是否大于-1(即text中是否存在openToken)，如果存在就执行下面代码
    char[] src = text.toCharArray();
    int offset = 0;
    final StringBuilder builder = new StringBuilder();
    StringBuilder expression = null;
    while (start > -1) {
     // 判断如果开始标记前如果有转义字符，就不作为openToken进行处理，否则继续处理
      if (start > 0 && src[start - 1] == '\\') {
        builder.append(src, offset, start - offset - 1).append(openToken);
        offset = start + openToken.length();
      } else {
        //重置expression变量，避免空指针或者老数据干扰。
        if (expression == null) {
          expression = new StringBuilder();
        } else {
          expression.setLength(0);
        }
        builder.append(src, offset, start - offset);
        offset = start + openToken.length();
        int end = text.indexOf(closeToken, offset);
        while (end > -1) {////存在结束标记时
          if (end > offset && src[end - 1] == '\\') {//如果结束标记前面有转义字符时
            // this close token is escaped. remove the backslash and continue.
            expression.append(src, offset, end - offset - 1).append(closeToken);
            offset = end + closeToken.length();
            end = text.indexOf(closeToken, offset);
          } else {//不存在转义字符，即需要作为参数进行处理
            expression.append(src, offset, end - offset);
            offset = end + closeToken.length();
            break;
          }
        }
        if (end == -1) {
          // close token was not found.
          builder.append(src, start, src.length - start);
          offset = src.length;
        } else {
          //首先根据参数的key（即expression）进行参数处理，返回?作为占位符
          builder.append(handler.handleToken(expression.toString()));
          offset = end + closeToken.length();
        }
      }
      start = text.indexOf(openToken, offset);
    }
    if (offset < src.length) {
      builder.append(src, offset, src.length - offset);
    }
    return builder.toString();
  }
}

 
  
 
   
 创建BoundSql类存储处理后的sql和参数对
 
  
 
  
package com.customer.executor;

import com.customer.util.ParameterMapping;

import java.util.List;

public class BoundSql {

    private String parseSql;

    private List<ParameterMapping> parameterMappingList;

    public BoundSql(String parseSql, List<ParameterMapping> parameterMappingList) {
        this.parseSql = parseSql;
        this.parameterMappingList = parameterMappingList;
    }

    public String getParseSql() {
        return parseSql;
    }

    public void setParseSql(String parseSql) {
        this.parseSql = parseSql;
    }

    public List<ParameterMapping> getParameterMappingList() {
        return parameterMappingList;
    }

    public void setParameterMappingList(List<ParameterMapping> parameterMappingList) {
        this.parameterMappingList = parameterMappingList;
    }
}

 
  
1.4 简单测试
 
  
package com.testcus.test;

import com.customer.config.Resources;
import com.customer.sqlsession.SqlSession;
import com.customer.sqlsession.SqlSessionFactory;
import com.customer.sqlsession.SqlSessionFactoryBuilder;
import com.testcus.pojo.User;
import org.junit.Test;

import java.io.InputStream;
import java.util.List;

public class MyTest {

    @Test
    public void Test() throws Exception {
        InputStream resourceAsSteam = Resources.getResourcesAsStream("mapperConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsSteam);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        List<User> userList = sqlSession.selectList("user.selectList");
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    

                        
                        

                            
 
                        
                        
                        

                            

                        
                        
                        

                            

                        
                    
                
            
        
    
    

        
你可能感兴趣的:(#,Mybatis,orm框架)
        

            

                

                    
insert into select 主键自增_mybatis拦截器实现主键自动生成
                        weixin_39521651
insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
                        
前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
                    
                    
MyBatis 详解
                        阿贾克斯的黎明
javamybatis
                        
目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
                    
                    
mybatis 二级缓存失效_Mybatis 缓存原理及失效情况解析
                        weixin_39844942
mybatis二级缓存失效
                        
这篇文章主要介绍了Mybatis缓存原理及失效情况解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下1、什么是缓存[Cache]存在内存中的临时数据。将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。2、为什么要使用缓存减少和数据库的交互次
                    
                    
详解mybatis的一二级缓存以及缓存失效原因
                        仰望天花板
缓存数据库mybatisjavamysql
                        
数据库的大部分场景下是从磁盘读取，如果数据从内存进行读取，速度较比磁盘要快得多。但因为内存的容量有限，所以一般只会把使用和查询较多的数据缓存起来，以便快速反应，其他使用率不太多的继续存放在磁盘。mybatis分为一级缓存和二级缓存1.一级缓存一级缓存存放在SqlSqeeion上，默认开启1.1pojo@DatapublicclassRole{privateLongid;privateStringr
                    
                    
36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
                        这孩子叫逆
Mybatis笔记mybatis数据库
                        
在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
                    
                    
MyBatis批量插入大量数据
                        小黑屋说YYDS
MyBatisjava
                        
1.思路分析批量插入这个问题，我们用JDBC操作，其实就是两种思路吧：用一个for循环，把数据一条一条的插入（这种需要开启批处理）。生成一条插入sql，类似这种insertintouser(username,address)values(‘aa’,‘bb’),(‘cc’,‘dd’)…。到底哪种快呢？我们从两方面来考虑这个问题：插入SQL本身执行的效率。网络I/O。先说第一种方案，就是用for循环循
                    
                    
MyBatis 查询数据库_mybatis查询某个库的所有表名(2)
                        2401_84181942
程序员mybatisoracletomcat
                        
标签说明：***``标签**：需要指定namespace属性，表示命名空间，值为mapper接口的全限定名，包括全包名.类名。***``查询标签**：是用来执行数据库的查询操作的：`id`：是和Interface（接口）中定义的方法名称一样的，表示对接口的具体实现方法。`resultType`：是返回的数据类型，也就是开头我们定义的实体类。####2.4.4添加Service服务层实现代码如下：@
                    
                    
5-【JavaWeb】JUnit 单元测试及JUL 日志系统
                        weixin_44329069
JavaWebjunit单元测试
                        
1.使用JUnit进行单元测试JUnit是Java中非常流行的单元测试框架，MyBatis与JUnit可以很好地结合，来测试持久层代码的正确性。1.1添加JUnit依赖在使用JUnit之前，需要在pom.xml中引入JUnit依赖。junitjunit4.13.2test1.2单元测试基本结构假设我们要测试UserMapper中的getUserById方法，测试代码如下：importorg.apa
                    
                    
【免费】springboot项目申报管理系统|毕业设计|Javaweb项目
                        计算机学姐来啦
springbootssmjavaspringboot课程设计后端毕设毕业设计java-ee
                        
收藏点赞不迷路关注作者有好处编号：springboot375springboot项目申报管理系统开发语言：Java数据库：MySQL技术：Spring+SpringMVC+MyBatis工具：IDEA/Ecilpse、Navicat、Maven1.万字文档展示(部分)2.系统图片展示第5章系统详细设计5.1管理员功能模块的实现5.1.1项目列表如图5.1显示的就是项目列表页面，此页面提供给管理员的
                    
                    
MyBatis系统学习（一）——项目结构及其含义
                        OEC小胖胖
MyBatismybatis学习web后端
                        
1.MyBatis简介MyBatis是一款优秀的持久层框架，它通过SQL映射的方式实现Java对数据库操作的映射，既保留了SQL语句的灵活性，也简化了代码的编写。在一个MyBatis项目中，核心部分主要有：配置文件（mybatis-config.xml）映射文件（Mapper.xml）实体类（Entity/POJO）接口类（Mapper接口）MyBatis会话工厂（SqlSessionFactor
                    
                    
MyBatis 如何将 Mapper 接口与其 XML 映射文件关联：深入原理与实现
                        OEC小胖胖
web后端mybatisxmljavaweb后端
                        
MyBatis如何将Mapper接口与其XML映射文件关联：深入原理与实现1.概述MyBatis是一个简单、灵活的持久层框架，它通过SQL语句将Java对象与数据库进行映射。MyBatis支持基于XML和注解的配置方式。在实际开发中，XML映射文件与Mapper接口的关联是MyBatis的核心功能之一。通过这种关联，开发者可以在Mapper接口中定义方法，并在XML文件中编写SQL语句，从而实现数
                    
                    
Mybatis实现员工管理系统
                        wu1113_
mybatisjavamaven
                        
文章目录1.案例需求2.编程思路3.案例源码4.小结1.案例需求在上次做的父子模块的maven以及Ajax实现人工管理系统的基础上使用Mybatis实现员工管理系统的增删改查，具体运行效果如下：2.编程思路Mybatis框架的一般执行流程：创建MyBatis配置文件mybatis-config.xml在里面加载数据源、事务等，管理映射文件创建需要的映射文件mapper.xml，用于映射表中列和实体
                    
                    
springboot+mybatisplus实现基本的增删改查以及分页查询。这里使用的是Restful风格包括简单描述Restful是什么
                        okchan666
springbootjava
                        
先实现springboot+mybatisplus的增删改查接口使用postman测试：第一步创建项目导入依赖：直接给大家了：4.0.0org.springframework.bootspring-boot-starter-parent2.6.6com.okchanspringboot_07_ssmp0.0.1-SNAPSHOT1.8org.springframework.bootspring-b
                    
                    
MyBatis 方法重载的陷阱及解决方案
                        molashaonian
mybatis方法重载异常方法名相同
                        
在使用MyBatis进行开发时，尤其是使用注解模式（如@Select、@Insert等）时，开发者常常会遇到这样一个问题：为什么我的方法重载不能正常工作？即使在Java中允许方法名相同但参数不同的重载，MyBatis在处理注解的SQL方法时却并不支持这种方式。这篇文章将深入探讨MyBatis的这个特性及如何规避相关的坑。问题背景在标准的Java开发中，方法重载是一种常见的设计模式。方法重载允许我们
                    
                    
Spring Cloud+Spring Boot+Mybatis+Java版电子招标采购系统源码 及 功能清单
                        Xiaohong0716
mybatisjavaspringcloud
                        
一、立项管理1、招标立项申请功能点：招标类项目立项申请入口，用户可以保存为草稿，提交。2、非招标立项申请功能点：非招标立项申请入口、用户可以保存为草稿、提交。3、采购立项列表功能点：对草稿进行编辑，驳回的立项编辑，在途流程查看。二、项目管理1、采购计划管理功能点：采购计划新增、编辑、删除2、采购过程管理功能点：查询、维护基准价、组建评审小组、项目答疑澄清、文件费保证金审核、供应商报价维护、查看评审
                    
                    
BindingException: Invalid bound statement (not found)
                        小卡车555
MyBatismybatisjavamysql
                        
Mybatis出现绑定异常问题的解决org.apache.ibatis.binding.BindingException:Invalidboundstatement(notfound)一般的原因是Mapperinterface和xml文件的定义对应不上，需要检查包名，namespace，函数名称等能否对应上，需要比较细致的对比，我经常就是写错了一两个字母搞的很长时间找不到错误按以下步骤一一执行：1
                    
                    
工程项目管理系统源码与Spring Cloud：实现高效系统管理与二次开发
                        微服务技术分享
springcloudjava工程项目管理系统源码
                        
随着企业规模的不断扩大和业务的快速发展，传统的工程项目管理方式已经无法满足现代企业的需求。为了提高工程管理效率、减轻劳动强度、提高信息处理速度和准确性，企业需要借助先进的数字化技术进行转型。本文将介绍一款采用SpringCloud+SpringBoot+Mybatis技术框架的工程项目管理系统，该系统涵盖了项目管理、合同管理、预警管理、竣工管理、质量管理等多个方面，通过数据字典、编码管理、用户管理
                    
                    
[附源码]SSM计算机毕业设计游戏账号交易平台JAVA
                        计算机程序源码
java游戏mysql
                        
项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也可以。2.ID
                    
                    
Mybatis Mysql
                        莫夏_b560

                        
1、查询失败或者结果异常andfwbdh=#{fwbdh}更换成andfwbdh=#{fwbdh}
                    
                    
33. MyBatis中的@Param注解如何使用？如何在Mapper接口中传递多个参数？
                        这孩子叫逆
Mybatis笔记javamybatistomcat
                        
在MyBatis中，@Param注解用于将方法参数绑定到SQL语句中的命名参数。它主要用于在Mapper接口中传递多个参数，以便在SQL语句中更方便地引用这些参数。为什么使用@Param注解？在MyBatis中，当Mapper接口的方法只有一个参数时，MyBatis会默认将这个参数的名称绑定为#{parameter}，可以直接在SQL语句中引用它。如果方法有多个参数，MyBatis默认使用para
                    
                    
Python+Django毕业设计校园易购二手交易平台（程序+LW+部署）
                        Python、JAVA毕设程序源码
课程设计javamysql
                        
项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也可以。2.ID
                    
                    
Springboot3 整合 Mybatis3
                        （前程似锦）
mybatisjavaspringboot
                        
Springboot3整合MybatisSpringboot3整合MybatisSpringboot3整合Mybatis一、导入依赖二、编写配置文件三、定义模型entity实体类四、在启动类上添加注解，表示mapper接口所在位置五、定义mapper接口六、定义mapper.xml映射文件七、service层八、测试一、导入依赖mybatis的必要依赖注意：使用springboot3的话要使用my
                    
                    
mybatis支持json，Spring boot配置
                        Knight_9

                        
mysql5.7版本以后支持原生json格式，基于Springboot进行配置说明。mybatis支持mysql的json格式mysql-connector，mysql的驱动版本要大于等于5.1.40，否则json字段查询会发生乱码。继承BaseTypeHandler自定义一个json类型处理器，放到一个handler包下，例：packagecom.c.config.handler;importc
                    
                    
【Java】Mybatis Druid连接池配置详细
                        beautiful_huang
Java
                        
pom.xmlcom.alibabadruid1.0.18.propertiesspring.datasource.driver-class-name=com.mysql.jdbc.Driverspring.datasource.url=jdbc:mysql://localhost:3306/mybatis2?characterEncoding=utf-8&useSSL=truespring.da
                    
                    
关于com.baomidou:mybatis-plus-boot-starter:jar:unknown was not found解决办法
                        波斯CD
mybatisjarjava
                        
原型com.baomidoumybatis-plus-boot-starter修改以后解决了com.baomidoumybatis-plus-boot-starter3.5.3.1
                    
                    
MyBatis-Plus 3.5.5的代码生成器 实践【完整代码】
                        qq_43513957
mybatis
                        
MyBatis-Plus3.5.5的代码生成器实践【完整代码】1.表：要有一个version字段，乐观锁更新。配置拦截器的代码packagecom.example.demo.zmybatisplusGenerator.config;importcom.baomidou.mybatisplus.annotation.DbType;importcom.baomidou.mybatisplus.exte
                    
                    
深入解析 MyBatis：从理论到项目实例
                        OEC小胖胖
web后端mybatisjavaspringweb后端
                        
深入解析MyBatis：从理论到项目实例目录MyBatis概述MyBatis项目结构及作用核心概念详解分页功能的实现与深入剖析动态SQL缓存机制详解与Spring集成常见问题与深入分析完整项目示例总结1.MyBatis概述MyBatis是一个轻量级的持久层框架，使用SQL查询语句来访问数据库。它与Java对象建立映射关系，通过配置文件或注解来管理SQL语句，灵活性高且与数据库操作直接相关，适合需要
                    
                    
【django】创建模型类(已更新)
                        敲代码敲到头发茂密
Django#ORM框架djangopython后端
                        
ORM框架一、创建模型类二、字段类型说明三、字段选项说明四、外键五、迁移六、添加测试数据a、数据库：需要提前手动创建数据库b、数据表：与ORM框架中的模型类一一对应c、字段：模型类中的类属性（Field子类）d、记录：类似于模型类的多个实例一、创建模型类模型类创建在应用目录/models.py文件中。模型类必须继承Model类，位于包django.db.models中。接下来首先以“影片-人物”管
                    
                    
MyBatis Plus 实战详解
                        Aries263
redis分布式数据库
                        
一、引言MyBatisPlus（简称MP）是MyBatis的增强工具，旨在简化开发、提高效率。它保留了MyBatis的强大功能，并在其基础上进行了扩展和优化，提供了强大的CRUD操作、配置选项、条件构造器等功能。本文将详细介绍MyBatisPlus的安装、配置、基本操作以及分页和条件查询的使用。二、安装与配置1.添加依赖首先，在Maven项目的pom.xml中添加MyBatisPlus的依赖。以下
                    
                    
在springboot中，利用xml配置mybatis的方法
                        猪猡猪猡猪
javamybatismybatisspringbootxmljavamysql
                        
前置步骤参考博客：SpringBoot配置Mybatis的两种方式（通过XML配置和通过YML配置文件配置）_Darreni的博客-CSDN博客但按照博客中的关键代码和步骤创建的项目无法启动启动报错：Description:FailedtoconfigureaDataSource:'url’attributeisnotspecif:Reason:Failedtodetermineasuitable
                    
                                
eclipse maven
                                    IXHONG
eclipse
                                    
eclipse中使用maven插件的时候，运行run as maven build的时候报错 
-Dmaven.multiModuleProjectDirectory system propery is not set. Check $M2_HOME environment variable and mvn script match. 
  
可以设一个环境变量M2_HOME指
                                
                                
timer cancel方法的一个小实例
                                    alleni123
多线程timer
                                    
package com.lj.timer;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class MyTimer extends TimerTask
{

	private int a;
	
	private Timer timer;
	
	pub
                                
                                
MySQL数据库在Linux下的安装
                                    ducklsl
mysql
                                    
1.建好一个专门放置MySQL的目录 
/mysql/db数据库目录 
/mysql/data数据库数据文件目录 
 
2.配置用户，添加专门的MySQL管理用户 
 
>groupadd mysql ----添加用户组
>useradd -g mysql mysql ----在mysql用户组中添加一个mysql用户 
3.配置，生成并安装MySQL 
 
>cmake -D
                                
                                
spring------>>cvc-elt.1: Cannot find the declaration of element
                                    Array_06
springbean
                                    
将-------- 
 
<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3
                                
                                
maven发布第三方jar的一些问题
                                    cugfy
maven
                                    
maven中发布 第三方jar到nexus仓库使用的是 deploy:deploy-file命令 
 
有许多参数，具体可查看 
 
http://maven.apache.org/plugins/maven-deploy-plugin/deploy-file-mojo.html 
 
以下是一个例子： 
 
mvn  deploy:deploy-file -DgroupId=xpp3 
                                
                                
MYSQL下载及安装
                                    357029540
mysql
                                    
    好久没有去安装过MYSQL，今天自己在安装完MYSQL过后用navicat for mysql去厕测试链接的时候出现了10061的问题，因为的的MYSQL是最新版本为5.6.24，所以下载的文件夹里没有my.ini文件，所以在网上找了很多方法还是没有找到怎么解决问题，最后看到了一篇百度经验里有这个的介绍，按照其步骤也完成了安装，在这里给大家分享下这个链接的地址
                                
                                
ios TableView cell的布局
                                    张亚雄
tableview
                                    
  cell.imageView.image = [UIImage imageNamed:[imageArray objectAtIndex:[indexPath row]]]; 
    
  
    CGSize itemSize = CGSizeMake(60, 50); 
 
  &nbs
                                
                                
Java编码转义
                                    adminjun
java编码转义
                                    
    import java.io.UnsupportedEncodingException;

    /**
    * 转换字符串的编码
    */
    public class ChangeCharset {
    /** 7位ASCII字符，也叫作ISO646-US、Unicode字符集的基本拉丁块 */
    public static final Strin
                                
                                
Tomcat 配置和spring
                                    aijuans
spring
                                    
简介 
Tomcat启动时，先找系统变量CATALINA_BASE，如果没有，则找CATALINA_HOME。然后找这个变量所指的目录下的conf文件夹，从中读取配置文件。最重要的配置文件：server.xml 。要配置tomcat，基本上了解server.xml，context.xml和web.xml。 
 
 Server.xml --  tomcat主
                                
                                
Java打印当前目录下的所有子目录和文件
                                    ayaoxinchao
递归File
                                    
其实这个没啥技术含量，大湿们不要操笑哦，只是做一个简单的记录，简单用了一下递归算法。 
  
import java.io.File;

/**
 * @author Perlin
 * @date 2014-6-30
 */
public class PrintDirectory {
	
	public static void printDirectory(File f
                                
                                
linux安装mysql出现libs报冲突解决
                                    BigBird2012
linux
                                    
linux安装mysql出现libs报冲突解决 
安装mysql出现 
file /usr/share/mysql/ukrainian/errmsg.sys from install of MySQL-server-5.5.33-1.linux2.6.i386 conflicts with file from package mysql-libs-5.1.61-4.el6.i686 
 
                                
                                
jedis连接池使用实例
                                    bijian1013
redisjedis连接池jedis
                                    
实例代码： 
package com.bijian.study;

import java.util.ArrayList;
import java.util.List;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoo
                                
                                
关于朋友
                                    bingyingao
朋友兴趣爱好维持
                                    
  成为朋友的必要条件： 
   志相同，道不合，可以成为朋友。譬如马云、周星驰一个是商人，一个是影星，可谓道不同，但都很有梦想，都要在各自领域里做到最好，当他们遇到一起，互相欣赏，可以畅谈两个小时。   
  志不同，道相合，也可以成为朋友。譬如有时候看到两个一个成绩很好每次考试争做第一，一个成绩很差的同学是好朋友。他们志向不相同，但他
                                
                                
【Spark七十九】Spark RDD API一
                                    bit1129
spark
                                    
aggregate 
package spark.examples.rddapi

import org.apache.spark.{SparkConf, SparkContext}

//测试RDD的aggregate方法
object AggregateTest {
  def main(args: Array[String]) {
    val conf = new Spar
                                
                                
ktap 0.1 released
                                    bookjovi
kerneltracing
                                    
Dear,

I'm pleased to announce that ktap release v0.1, this is the first official
release of ktap project, it is expected that this release is not fully
functional or very stable and we welcome bu
                                
                                
能保存Properties文件注释的Properties工具类
                                    BrokenDreams
properties
                                    
        今天遇到一个小需求：由于java.util.Properties读取属性文件时会忽略注释，当写回去的时候，注释都没了。恰好一个项目中的配置文件会在部署后被某个Java程序修改一下，但修改了之后注释全没了，可能会给以后的参数调整带来困难。所以要解决这个问题。 
    &nb
                                
                                
读《研磨设计模式》-代码笔记-外观模式-Facade
                                    bylijinnan
java设计模式
                                    
声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



/*
 * 百度百科的定义：
 * Facade（外观）模式为子系统中的各类（或结构与方法）提供一个简明一致的界面，
 * 隐藏子系统的复杂性，使子系统更加容易使用。他是为子系统中的一组接口所提供的一个一致的界面
 * 
 * 可简单地
                                
                                
After Effects教程收集
                                    cherishLC
After Effects
                                    
1、中文入门 
 
http://study.163.com/course/courseMain.htm?courseId=730009 
 
 2、videocopilot英文入门教程（中文字幕） 
 
http://www.youku.com/playlist_show/id_17893193.html 
英文原址： 
http://www.videocopilot.net/basic/ 
素
                                
                                
Linux Apache 安装过程
                                    crabdave
apache
                                    
Linux Apache 安装过程 
  
下载新版本： 
apr-1.4.2.tar.gz（下载网站：http://apr.apache.org/download.cgi） 
apr-util-1.3.9.tar.gz（下载网站：http://apr.apache.org/download.cgi） 
httpd-2.2.15.tar.gz（下载网站：http://httpd.apac
                                
                                
Shell学习 之 变量赋值和引用
                                    daizj
shell变量引用赋值
                                    
本文转自：http://www.cnblogs.com/papam/articles/1548679.html 
 
Shell编程中，使用变量无需事先声明，同时变量名的命名须遵循如下规则： 
 
首个字符必须为字母（a-z，A-Z） 
中间不能有空格，可以使用下划线（_） 
不能使用标点符号 
不能使用bash里的关键字（可用help命令查看保留关键字） 
需要给变量赋值时，可以这么写： 
 

                                
                                
Java SE 第一讲（Java SE入门、JDK的下载与安装、第一个Java程序、Java程序的编译与执行）
                                    dcj3sjt126com
javajdk
                                    
Java SE 第一讲： 
 
Java SE：Java Standard Edition 
Java ME: Java Mobile Edition 
Java EE：Java Enterprise Edition 
 
Java是由Sun公司推出的（今年初被Oracle公司收购）。 
 
收购价格：74亿美金 
 
J2SE、J2ME、J2EE 
 
JDK：Java Development 
                                
                                
YII给用户登录加上验证码
                                    dcj3sjt126com
yii
                                    
1、在SiteController中添加如下代码： 
    /**
     * Declares class-based actions.
     */
    public function actions() {
        return array(
            // captcha action renders the CAPTCHA image displ
                                
                                
Lucene使用说明
                                    dyy_gusi
Lucenesearch分词器
                                    
Lucene使用说明 
1、lucene简介 
1.1、什么是lucene 
    Lucene是一个全文搜索框架，而不是应用产品。因此它并不像baidu或者googleDesktop那种拿来就能用，它只是提供了一种工具让你能实现这些产品和功能。 
1.2、lucene能做什么 
    要回答这个问题，先要了解lucene的本质。实际
                                
                                
学习编程并不难,做到以下几点即可!
                                    gcq511120594
数据结构编程算法
                                    
不论你是想自己设计游戏，还是开发iPhone或安卓手机上的应用，还是仅仅为了娱乐，学习编程语言都是一条必经之路。编程语言种类繁多，用途各 异，然而一旦掌握其中之一，其他的也就迎刃而解。作为初学者，你可能要先从Java或HTML开始学，一旦掌握了一门编程语言，你就发挥无穷的想象，开发 各种神奇的软件啦。 
1、确定目标 
学习编程语言既充满乐趣，又充满挑战。有些花费多年时间学习一门编程语言的大学生到
                                
                                
Java面试十问之三：Java与C++内存回收机制的差别
                                    HNUlanwei
javaC++finalize()堆栈内存回收
                                    
大家知道， Java 除了那 8 种基本类型以外，其他都是对象类型（又称为引用类型）的数据。 JVM 会把程序创建的对象存放在堆空间中，那什么又是堆空间呢？其实，堆（ Heap）是一个运行时的数据存储区，从它可以分配大小各异的空间。一般，运行时的数据存储区有堆（ Heap）和堆栈（ Stack），所以要先看它们里面可以分配哪些类型的对象实体，然后才知道如何均衡使用这两种存储区。一般来说，栈中存放的
                                
                                
第二章 Nginx+Lua开发入门
                                    jinnianshilongnian
nginxlua
                                    
Nginx入门 
本文目的是学习Nginx+Lua开发，对于Nginx基本知识可以参考如下文章： 
nginx启动、关闭、重启 
http://www.cnblogs.com/derekchen/archive/2011/02/17/1957209.html 
agentzh 的 Nginx 教程 
http://openresty.org/download/agentzh-nginx-tutor
                                
                                
MongoDB windows安装 基本命令
                                    liyonghui160com

                                    
  
windows安装 
  
 安装目录： 
  
D:\MongoDB\ 
  
新建目录 
  
D:\MongoDB\data\db 
  
4.启动进城： 
  
cd D:\MongoDB\bin 
  
mongod -dbpath D:\MongoDB\data\db 
  
&n
                                
                                
Linux下通过源码编译安装程序
                                    pda158
linux
                                    
一、程序的组成部分   　　Linux下程序大都是由以下几部分组成：   　　二进制文件：也就是可以运行的程序文件   　　库文件：就是通常我们见到的lib目录下的文件   　　配置文件：这个不必多说，都知道   　　帮助文档：通常是我们在linux下用man命令查看的命令的文档   　　 
二、linux下程序的存放目录   　　linux程序的存放目录大致有三个地方：   　　/etc, /b
                                
                                
WEB开发编程的职业生涯４个阶段
                                    shw3588
编程Web工作生活
                                    
觉得自己什么都会 
2007年从学校毕业，凭借自己原创的ASP毕业设计，以为自己很厉害似的，信心满满去东莞找工作，找面试成功率确实很高，只是工资不高，但依旧无法磨灭那过分的自信，那时候什么考勤系统、什么OA系统、什么ERP，什么都觉得有信心，这样的生涯大概持续了约一年。 
 
根本不是自己想的那样 
2008年开始接触很多工作相关的东西，发现太多东西自己根本不会，都需要去学，不管是asp还是js，
                                
                                
遭遇jsonp同域下变作post请求的坑
                                    vb2005xu
jsonp同域post
                                    
今天迁移一个站点时遇到一个坑爹问题,同一个jsonp接口在跨域时都能调用成功,但是在同域下调用虽然成功,但是数据却有问题. 此处贴出我的后端代码片段 
$mi_id = htmlspecialchars(trim($_GET['mi_id ']));
$mi_cv = htmlspecialchars(trim($_GET['mi_cv '])); 
 贴出我前端代码片段: 
$.aj
                                
                
            
        
    


    

        

            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
        
    


    

        

            首页 -
            关于我们 -
            站内搜索 -
            Sitemap -
            侵权投诉
        
        
版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.