spring如何使用servlet spring如何使用sdk包

1.新建一个maven项目

新建一个maven项目，然后删除无用的东西

2.pom包配置

设置该jar包的路径，还有打包方式，依赖了一个commons-lang3包，在代码中有调用方法，然后是构建方式，采用jdk1.8进行开发和构建。

<groupId>com.cn.lg.sdk</groupId>
    <artifactId>spring-sdk</artifactId>
    <version>0.0.1</version>
    <name>spring-sdk</name>
    <description>Write and package the java SDK</description>

    <!-- 打包方式为jar包 -->
    <packaging>jar</packaging>

    <dependencies>
        <!-- 使用StringUtils工具类 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.4</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.7.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>

            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <mainClass>com.cn.lg.test.utils.LGInstanceUtils</mainClass>
                        </manifest>
                    </archive>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

3.开发自己需要的内容

这里写了两个对外的方法，分别是初始化对象和校验字符串是否为空。

对外提供了两个工具类：LGInstanceUtils和LGValidateUtils

1. Instance
   写了4个方法，初始化List和Hash

/**
     * 初始化ArrayList
     */
    public <T> ArrayList<T> newArrayList() {
        return new ArrayList<>();
    }

    /**
     * 初始化LinkedList
     */
    public <T> LinkedList<T> newLinkedList() {
        return new LinkedList<>();
    }

    /**
     * 初始化HashMap
     */
    public <K, V> HashMap<K, V> newHashMap() {
        return new HashMap<>();
    }

    /**
     * 初始化LinkedHashMap
     */
    public <K, V> LinkedHashMap<K, V> newLinkedHashMap() {
        return new LinkedHashMap<>();
    }

2. Validate
   对字符串进行校验是否为空

/**
     * 字符串是否为空
     * @param str   String字符串
     * @return  boolean
     */
    public boolean isEmptyStr(String str) {
        return StringUtils.isEmpty(str);
    }

3. LGInstanceUtils
   对Instance方法进行调用的封装，对外

private static LGInstanceUtils lgInstanceUtils = null;

    private Instance instance = new Instance();

    /**
     * 对Instance方法进行实例化，获取单例的LGInstanceUtils 并且供该类中其他方法调用，不允许其他类方法进行调用
     * @return  Instance
     */
    private static Instance getInstance() {
        if(lgInstanceUtils == null) {
             lgInstanceUtils = new LGInstanceUtils();
        }
        return lgInstanceUtils.instance;
    }

    public static <T> List<T> newArrayList() {
        return getInstance().newArrayList();
    }

    public static <T> List<T> newLinkedList() {
        return getInstance().newLinkedList();
    }

    public static <K, V> Map<K, V> newHashMap() {
        return getInstance().newHashMap();
    }

    public static <K, V> Map<K, V> newLinkedHashMap() {
        return getInstance().newLinkedHashMap();
    }

4. LGValidateUtils
   对Validate方法进行封装，对外

private static LGValidateUtils lgValidateUtils = null;

    private Validate validate = new Validate();

    /**
     * 对Instance方法进行实例化，获取单例的LGInstanceUtils 并且供该类中其他方法调用，不允许其他类方法进行调用
     * @return  Instance
     */
    private static Validate getInstance() {
        if(lgValidateUtils == null) {
            lgValidateUtils = new LGValidateUtils();
        }
        return lgValidateUtils.validate;
    }

    /**
     * 字符串是否为空
     * @param str   String字符串
     * @return  boolean
     */
    public static boolean isEmptyStr(String str) {
        return getInstance().isEmptyStr(str);
    }

4.打jar包

一种简单的方法：

打开IDEA的maven管理页面，找到自己的模块，然后直接点击package

打包成功后控制台会有jar包的输出路径：

5.在其他项目中使用自己的jar包

找到自己的jar包，一种是上传到maven仓库，然后所有人都可以使用了。

我由于是自己用，打开一个新的模块（使用之前的spring-test模块），直接复制到resource目录下边，然后开始配置：

打开自己的项目架构，找到刚才的模块，选择Dependencies，右侧加号，选第一个：

然后选择刚刚复制进来的包：

直接Apply就可以

6.测试jar包

然后新建一个类，进行测试：
可以看到引入了自己jar包中的类，并可以正常使用

import com.cn.lg.sdk.LGInstanceUtils;
import com.cn.lg.sdk.LGValidateUtils;

import java.util.List;

public class SpringSDKUtils {

    public static void main(String[] args) {
        newArrayList();
        isEmpty();
    }

    public static void newArrayList() {
        List<Integer> list = LGInstanceUtils.newArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list.toString());
    }

    public static void isEmpty() {
        System.out.println(LGValidateUtils.isEmptyStr(null));
    }
}

输出结果：

这种只是自己随便使用，正常还是直接加入maven中，并且打jar包的时候不要把依赖打入进去，要不然jar包会很大。