Jsp 有没有更有效的方法来编写这个Jsoup代码

我正在用jsp制作一个网站来比较不同购物网站的产品价格，我在1个jsp页面上以以下方式编写了代码：

try
{
 jsoup.connect(first_website)
 /* code for fetching prices and images */
 /* Html code for displaying prices and images */     
} catch(){}

try
{
 jsoup.connect(second_website)
 /* code for fetching prices and images */
 /* Html code for displaying prices and images */
} catch(){}

try
{
 jsoup.connect(third_website)
 /* code for fetching prices and images */
 /* Html code for displaying prices and images */
} catch(){}

此代码显示同一页面上三个网站的搜索结果，用于单个搜索查询。但问题是，我的网站现在加载速度很慢，有时某个或其他网站的结果不会显示出来。它给了我以下错误：

org.jsoup.HttpStatusException: HTTP error fetching URL.Status=500,URL=/*websitename*/

---

最好使用多个线程来请求站点，因此您将同时向站点发送请求

您可以通过java任务执行器服务这样做：

    FutureTask<Boolean> futureTask1 = new FutureTask<Boolean>(new Callable<Boolean>()
    {
        @Override
        public Boolean call() throws Exception
        {
            try
            {
                //jsoup.connect(second_website)
                 /* code for fetching prices and images */
                 /* Html code for displaying prices and images */
                return true;
            } catch(Exception e){
                return false;
            }

        }
    });

    FutureTask<Boolean> futureTask2 = new FutureTask<Boolean>(new Callable<Boolean>()
    {
        @Override
        public Boolean call() throws Exception
        {
            //Same as above
        }
    });

    FutureTask<Boolean> futureTask3 = new FutureTask<Boolean>(new Callable<Boolean>()
    {
        @Override
        public Boolean call() throws Exception
        {
            //Same as above
        }
    });

    ExecutorService executorService = Executors.newFixedThreadPool(3);

    executorService.execute(futureTask1);
    executorService.execute(futureTask2);
    executorService.execute(futureTask3);

    while (true){
        if(futureTask1.isDone() && futureTask2.isDone() && futureTask3.isDone()){
            //Here work is done
            try
            {
                if(futureTask1.get()){
                    //task 1 done it's work correctly
                }else {
                    //some problem in task 
                }
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }

        }

        try
        {
            Thread.sleep(100);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }

FutureTask futureTask1=newfuturetask（newcallable（））
{
@凌驾
公共布尔调用（）引发异常
{
尝试
{
//jsoup.connect（第二大学网站）
/*获取价格和图像的代码*/
/*用于显示价格和图像的Html代码*/
返回true；
}捕获（例外e）{
返回false；
}
}
});
FutureTask futureTask2=新的FutureTask（新的可调用（）
{
@凌驾
公共布尔调用（）引发异常
{
//同上
}
});
FutureTask futureTask3=新的FutureTask（新的可调用（）
{
@凌驾
公共布尔调用（）引发异常
{
//同上
}
});
ExecutorService ExecutorService=Executors.newFixedThreadPool（3）；
executorService.execute（未来任务1）；
executorService.execute（未来任务2）；
executorService.execute（未来任务3）；
while（true）{
if（futureTask1.isDone（）&&futureTask2.isDone（）&&futureTask3.isDone（））{
//工作完成了
尝试
{
if（futureTask1.get（））{
//任务1正确完成了
}否则{
//任务中的一些问题
}
}
捕获（例外e）
{
e、 printStackTrace（）；
}
}
尝试
{
睡眠（100）；
}
捕捉（中断异常e）
{
e、 printStackTrace（）；
}
}

---

如果这些任务之间有共同的逻辑，则可以创建一个实现

可调用
接口的类，并将站点url传递给其构造函数。
最好使用多个线程来请求站点，以便同时向站点发送请求

您可以通过java任务执行器服务这样做：

    FutureTask<Boolean> futureTask1 = new FutureTask<Boolean>(new Callable<Boolean>()
    {
        @Override
        public Boolean call() throws Exception
        {
            try
            {
                //jsoup.connect(second_website)
                 /* code for fetching prices and images */
                 /* Html code for displaying prices and images */
                return true;
            } catch(Exception e){
                return false;
            }

        }
    });

    FutureTask<Boolean> futureTask2 = new FutureTask<Boolean>(new Callable<Boolean>()
    {
        @Override
        public Boolean call() throws Exception
        {
            //Same as above
        }
    });

    FutureTask<Boolean> futureTask3 = new FutureTask<Boolean>(new Callable<Boolean>()
    {
        @Override
        public Boolean call() throws Exception
        {
            //Same as above
        }
    });

    ExecutorService executorService = Executors.newFixedThreadPool(3);

    executorService.execute(futureTask1);
    executorService.execute(futureTask2);
    executorService.execute(futureTask3);

    while (true){
        if(futureTask1.isDone() && futureTask2.isDone() && futureTask3.isDone()){
            //Here work is done
            try
            {
                if(futureTask1.get()){
                    //task 1 done it's work correctly
                }else {
                    //some problem in task 
                }
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }

        }

        try
        {
            Thread.sleep(100);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }

FutureTask futureTask1=newfuturetask（newcallable（））
{
@凌驾
公共布尔调用（）引发异常
{
尝试
{
//jsoup.connect（第二大学网站）
/*获取价格和图像的代码*/
/*用于显示价格和图像的Html代码*/
返回true；
}捕获（例外e）{
返回false；
}
}
});
FutureTask futureTask2=新的FutureTask（新的可调用（）
{
@凌驾
公共布尔调用（）引发异常
{
//同上
}
});
FutureTask futureTask3=新的FutureTask（新的可调用（）
{
@凌驾
公共布尔调用（）引发异常
{
//同上
}
});
ExecutorService ExecutorService=Executors.newFixedThreadPool（3）；
executorService.execute（未来任务1）；
executorService.execute（未来任务2）；
executorService.execute（未来任务3）；
while（true）{
if（futureTask1.isDone（）&&futureTask2.isDone（）&&futureTask3.isDone（））{
//工作完成了
尝试
{
if（futureTask1.get（））{
//任务1正确完成了
}否则{
//任务中的一些问题
}
}
捕获（例外e）
{
e、 printStackTrace（）；
}
}
尝试
{
睡眠（100）；
}
捕捉（中断异常e）
{
e、 printStackTrace（）；
}
}

如果这些任务之间有共同的逻辑，可以创建一个实现
Callable
接口的类，并将站点url传递给其构造函数